/*
catcrafts.net
Copyright (C) 2026 Catcrafts

The source code of this website is made available for viewing purposes only.
No permission is granted to copy, modify, distribute, or create derivative works.
*/

// The whole order lifecycle against the real binary: checkout, the payment
// choice, export pricing, the refusals, the fake rail settling, the signed
// invoice, the confirmation email, and the financials page agreeing with the
// ledger. The fake payment rail makes this testable: it hands out pretend
// payment links and reports "paid" once the marker file exists — which is how
// this suite simulates the customer paying.
//
// The lifecycle half runs only while the shop is OPEN; while coming-soon it
// asserts the closed behaviour instead. Launch day (status flip to
// "available" in Catcrafts.Shared-Content.cppm) re-arms the full suite with
// no edit here. The validation half runs in both states on purpose:
// validation happens before the coming-soon check, and that ordering is
// exactly what it pins.

import std;
import Catcrafts.Shared;
import Crafter.Network;
import Catcrafts.E2eHarness;

using namespace Catcrafts;
using namespace Catcrafts::E2e;

namespace {

constexpr std::string_view kGood =
    "email=e2e%40example.org&name=Ada%20Lovelace&street=Main%20St%201&postal=1234AB&city=Delft&country=nl";

std::string Good(std::string_view suffix = {}) {
    return std::string(kGood) + std::string(suffix);
}

// The order token from a checkout redirect's Location header.
std::string TokenOf(const Crafter::HTTPResponse& r) {
    const auto it = r.headers.find("location");
    if (it == r.headers.end()) return {};
    std::smatch m;
    if (std::regex_search(it->second, m, std::regex(R"(/order/([0-9a-f]{32})$)"))) {
        return m[1].str();
    }
    return {};
}

// The ledger is JSONL — one event per line.
std::vector<std::string> LedgerLines(TestServer& srv) {
    std::vector<std::string> lines;
    for (auto part : std::views::split(srv.OrdersText(), '\n')) {
        std::string_view line(part.begin(), part.end());
        if (!line.empty()) lines.emplace_back(line);
    }
    return lines;
}

std::size_t MailCount(TestServer& srv) {
    std::size_t n = 0;
    for (const auto& entry : std::filesystem::directory_iterator(srv.Work())) {
        const std::string name = entry.path().filename().string();
        if (name.starts_with("mail-") && name.ends_with(".eml")) ++n;
    }
    return n;
}

// Wait until `predicate` holds, on the reconciler/mailer cadence.
bool SettleUntil(std::function<bool()> predicate, std::int32_t tries = 40) {
    for (std::int32_t i = 0; i < tries; ++i) {
        if (predicate()) return true;
        std::this_thread::sleep_for(std::chrono::milliseconds(250));
    }
    return predicate();
}

bool GpgVerifies(const std::filesystem::path& file) {
    return std::system(std::format("gpg --verify {} >/dev/null 2>&1",
                                   file.string()).c_str()) == 0;
}

void OpenShopLifecycle(TestServer& srv) {
    // ── checkout ──────────────────────────────────────────────────────
    // A valid submission answers 303 straight to the PAYMENT page — no
    // interim stop. The fake rail's payUrl is the order page itself, so the
    // token is still extractable from the Location and the browser flow works
    // in dev.
    const auto checkout = srv.Post("/shop/fp6-pmos", Good());
    const std::string token = TokenOf(checkout);
    Check(checkout.status == "303" && !token.empty(),
          "POST checkout -> 303 straight to payment", checkout.status);
    {
        const std::string ledger = srv.OrdersText();
        Check(ledger.find("\"country\":\"NL\"") != std::string::npos
                  && ledger.find("\"total_minor\":57830") != std::string::npos,
              "order stored: NL total is €578.30 (green €563.30 + €15 shipping)");
        // No `pay` field in that submission, which is what a form with only
        // one rail configured posts: it must land on the bank rail rather
        // than nothing.
        Check(ledger.find("\"pay_choice\":\"bank\"") != std::string::npos,
              "a submission with no payment choice records bank");
    }

    // The order page: awaiting payment, pay link, reference, self-refreshing,
    // never indexed, never cached.
    const std::string orderPath = std::format("/order/{}", token);
    {
        const std::string page = srv.Body(orderPath);
        for (std::string_view probe : { "awaiting payment", "Resume payment", "CC-",
                                        "http-equiv=\"refresh\"", "€578.30" }) {
            Check(page.find(probe) != std::string::npos,
                  std::format("order page has {}", probe));
        }
    }
    srv.HeaderHas(orderPath, "x-robots-tag", "noindex", "order page is noindex");
    srv.HeaderHas(orderPath, "cache-control", "no-store", "order page is never cached");

    // Unknown and malformed tokens are the same 404.
    srv.CheckStatus("/order/00000000000000000000000000000000", "404");
    srv.CheckStatus("/order/not-a-token", "404");
    srv.CheckStatus("/order/deadbeef", "404");

    // ── the payment choice ────────────────────────────────────────────
    // Both slots are configured here, so the form must offer both and the
    // picked one must survive all the way into the ledger. The ledger is the
    // assertion that matters: it is what the reconciler later reads to decide
    // WHICH provider may confirm the order, so a choice that renders but is
    // not stored would mean crypto orders being asked about at Mollie.
    srv.BodyHas("/shop/fp6-pmos", "name=\"pay\"", "the form offers a payment choice");
    srv.BodyHas("/shop/fp6-pmos", "value=\"crypto\"", "crypto is one of the choices");
    srv.BodyHas("/shop/fp6-pmos", "value=\"bank\" checked", "bank is the pre-selected choice");

    const std::string tokenCrypto = TokenOf(srv.Post("/shop/fp6-pmos", Good("&pay=crypto")));
    Check(!tokenCrypto.empty(), "a crypto order goes through");
    if (!tokenCrypto.empty()) {
        bool recorded = false;
        for (const std::string& line : LedgerLines(srv)) {
            if (line.find(std::format("\"id\":\"{}\"", tokenCrypto)) != std::string::npos) {
                recorded = recorded
                           || line.find("\"pay_choice\":\"crypto\"") != std::string::npos;
            }
        }
        Check(recorded, "the crypto choice is what the ledger records");
        // The order page has to promise what is actually behind the button —
        // the bank copy on a crypto order would send someone looking for
        // iDEAL. (The shell suite pinned 'Lightning' here, CoinGate-era copy
        // that had already left the codebase — this is the check that caught
        // the drift when the port first ran against an open shop.)
        const std::string page = srv.Body(std::format("/order/{}", tokenCrypto));
        Check(page.find("completes your crypto payment") != std::string::npos,
              "the crypto order page describes the crypto payment");
        Check(page.find("iDEAL") == std::string::npos,
              "the crypto order page does not promise iDEAL");
    }

    // A payment method nobody offers is refused, and refused as a FIELD error
    // so the form comes back with the choice highlighted rather than a bare
    // 400.
    {
        const auto bogus = srv.Post("/shop/fp6-pmos", Good("&pay=invoice-me-later"));
        Check(bogus.status == "422", "an unknown payment method is refused", bogus.status);
        Check(bogus.body.find("Pick one of the payment methods") != std::string::npos,
              "the refusal names the payment field");
    }

    // A non-EU order: ex-VAT goods, world shipping, and the indicative
    // national currency line sourced from the build-time ECB rates. GB rather
    // than a North American destination because those are refused outright.
    const std::string tokenGb = TokenOf(srv.Post("/shop/fp6-pmos",
        "email=gb%40example.org&name=Terry&street=1%20Baker%20St&postal=W1U&city=London&country=GB"));
    Check(!tokenGb.empty(), "GB checkout issues an order");
    if (!tokenGb.empty()) {
        const std::string page = srv.Body(std::format("/order/{}", tokenGb));
        // €465.54 goods (green net) + €55 world shipping = €520.54
        Check(page.find("€520.54") != std::string::npos,
              "export order total is ex-VAT + world shipping");
        Check(page.find("Zero-rated export") != std::string::npos,
              "export order states the VAT treatment");
        Check(std::regex_search(page, std::regex("≈ £[0-9]+")),
              "export order shows the indicative GBP amount");
        Check(page.find("indicative") != std::string::npos,
              "conversion is labelled indicative");
    }

    // A two-unit white export order: unit €665, line €1330, net from the LINE
    // total (not per unit) = €1082.45, plus €55 world shipping = €1137.45.
    const std::string tokenWhite = TokenOf(srv.Post("/shop/fp6-pmos",
        "email=w%40example.org&name=W&street=X%201&postal=1&city=Y&country=GB&color=white&quantity=2"));
    Check(!tokenWhite.empty(), "white ×2 checkout issues an order");
    if (!tokenWhite.empty()) {
        const std::string page = srv.Body(std::format("/order/{}", tokenWhite));
        Check(page.find("€1137.45") != std::string::npos,
              "white ×2 export total nets the line, not the unit");
        Check(page.find("Device × 2") != std::string::npos, "order page shows the quantity");
        Check(page.find("White") != std::string::npos, "order page names the colour");
    }

    // A colour we never listed must not buy anything, whatever the form claims.
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST", Good("&color=mauve"));
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST", Good("&quantity=100"));
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST", Good("&quantity=0"));
    // Quantity is a free input with a technical ceiling, not a dropdown — a
    // nine-unit order is business, not fraud.
    Check(!TokenOf(srv.Post("/shop/fp6-pmos", Good("&quantity=9"))).empty(),
          "a nine-unit order goes through");
    srv.BodyHas("/shop/fp6-pmos", "type=\"number\"", "quantity is a number input, not a dropdown");
    // The ceiling is physical: the heaviest band any destination offers
    // (10 kg in the fixture) divided by the boxed unit weight (700 g) = 14.
    // The input advertises the BEST case across destinations; the per-country
    // limit is enforced on submit, below.
    srv.BodyHas("/shop/fp6-pmos", "max=\"14\"", "quantity input carries the one-parcel ceiling");

    // One order is one parcel. Fifteen units is 10.5 kg, past every band the
    // fixture has, so it must be refused rather than quoted a rate the
    // carrier would not accept — and the refusal has to say what WOULD fit,
    // or the buyer is left guessing.
    {
        const auto heavy = srv.Post("/shop/fp6-pmos", Good("&quantity=15"));
        Check(heavy.status == "422", "an over-weight order is refused", heavy.status);
        Check(heavy.body.find("up to 14 per order") != std::string::npos,
              "the too-heavy refusal says what fits");
        Check(heavy.body.find("orders@catcrafts.net") != std::string::npos,
              "the too-heavy refusal offers a way to order anyway");
    }

    // A destination the carrier has no rate for. Since the zone fallback went
    // away there is no price to invent, so this is a refusal — and
    // specifically NOT the no-sale refusal, which is a different (policy)
    // reason with different wording.
    constexpr std::string_view kAu =
        "email=au%40example.org&name=Alex&street=1%20George%20St&postal=2000&city=Sydney&country=AU";
    {
        const auto au = srv.Post("/shop/fp6-pmos", std::string(kAu));
        Check(au.status == "422", "an uncovered destination is refused", au.status);
        Check(au.body.find("No carrier rate for AU") != std::string::npos,
              "an uncovered destination is refused, naming the country");
        // The country FIELD ERROR must be the carrier message, not the
        // no-sale one. Matched on the error markup rather than the bare
        // sentence: the no-sale line is standing copy above every buy form.
        Check(au.body.find("field__error\">Catcrafts does not sell") == std::string::npos,
              "an uncovered destination is not confused with a refused one");
        const std::size_t before = LedgerLines(srv).size();
        srv.Post("/shop/fp6-pmos", std::string(kAu));
        Check(LedgerLines(srv).size() == before, "a refused destination writes no order");
    }

    // No invoice exists before the money does — awaiting orders answer 404.
    srv.CheckStatus(std::format("/order/{}/invoice.md", token), "404");
    srv.CheckStatus("/order/00000000000000000000000000000000/invoice.md", "404");

    // ── the payment lands ─────────────────────────────────────────────
    // Create the fake rail's paid marker, then the reconciler (1 s cadence in
    // fake mode) must flip the order within a few seconds. The paid state
    // shows the confirmation notice, deliberately WITHOUT a second "paid"
    // badge — so the success marker is the notice text.
    WriteFile(std::filesystem::path(srv.Orders().string() + ".fake-paid"), "");
    {
        const std::string page = srv.WaitForBody(orderPath, "order is confirmed");
        Check(page.find("order is confirmed") != std::string::npos,
              "order confirms after payment (arrival poll or reconciler)");
        const std::size_t badges = CountOccurrences(page, "badge--active");
        Check(badges == 0, "no duplicate paid badge next to the confirmation",
              std::format("found {} active badges", badges));
        Check(page.find("http-equiv=\"refresh\"") == std::string::npos,
              "paid order page stops self-refreshing");
    }
    {
        const std::string ledger = srv.OrdersText();
        Check(ledger.find("\"type\":\"status\"") != std::string::npos
                  && ledger.find("\"status\":\"paid\"") != std::string::npos,
              "paid transition is an appended event, not a rewrite");
        // The paid event records HOW it was paid — card money stays
        // reversible for months, so the ledger must show which orders carry
        // that tail.
        Check(ledger.find("\"via\":\"fake\"") != std::string::npos,
              "paid event records the payment method");
    }

    // ── the signed invoice ────────────────────────────────────────────
    // Paid orders download a clearsigned markdown invoice: sequential number,
    // registered identity, amounts — and a signature that verifies offline.
    {
        const auto invoice = srv.Get(std::format("/order/{}/invoice.md", token));
        for (std::string_view probe : { "BEGIN PGP SIGNED MESSAGE", "# Invoice ",
                                        "Customer number: ", "Chico Mendesring 256",
                                        "KVK 78437059", "NL003329281B38", "CC-",
                                        "VAT 21% (NL)", "€578.30" }) {
            Check(invoice.body.find(probe) != std::string::npos,
                  std::format("invoice has {}", probe));
        }
        const auto disposition = invoice.headers.find("content-disposition");
        Check(disposition != invoice.headers.end()
                  && disposition->second.find("attachment") != std::string::npos,
              "invoice downloads as an attachment");
        const std::filesystem::path file = srv.Work() / "invoice.md";
        WriteFile(file, invoice.body);
        Check(GpgVerifies(file), "invoice signature verifies with gpg");
    }

    // Several orders were placed before the marker (two of them by the same
    // email); the arrival poll paid one instantly, the reconciler sweeps the
    // rest on its 1 s cadence — wait for all four invoices before judging the
    // numbering.
    SettleUntil([&] {
        return CountOccurrences(srv.OrdersText(), "\"type\":\"invoice\"") >= 4;
    });

    // Per-customer series, continuing the pre-shop administration: numbers
    // are <customer-uuid>-<seq>, unique overall, and orders that share an
    // email share a series with distinct sequence numbers.
    {
        const std::string ledger = srv.OrdersText();
        const std::size_t invoices = CountOccurrences(ledger, "\"type\":\"invoice\"");
        std::set<std::string> numbers;
        bool uuidSeries = false;
        const std::regex numberField(R"lit("number":"([0-9a-f-]*)")lit");
        const std::regex uuidSeq(
            R"(^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}-[0-9]+$)");
        for (auto it = std::sregex_iterator(ledger.begin(), ledger.end(), numberField);
             it != std::sregex_iterator(); ++it) {
            numbers.insert((*it)[1].str());
            uuidSeries = uuidSeries || std::regex_match((*it)[1].str(), uuidSeq);
        }
        Check(invoices > 0 && invoices == numbers.size(),
              std::format("invoice numbers are unique ({} issued)", invoices));
        Check(uuidSeries, "invoice numbers are customer-uuid series");
        // The GOOD email placed several paid orders in this run — all of them
        // must sit in ONE customer series (same uuid), with as many distinct
        // sequence numbers.
        std::set<std::string> customers;
        const std::regex customerField(R"lit("customer":"([0-9a-f-]*)")lit");
        for (auto it = std::sregex_iterator(ledger.begin(), ledger.end(), customerField);
             it != std::sregex_iterator(); ++it) {
            customers.insert((*it)[1].str());
        }
        Check(customers.size() < invoices,
              std::format("repeat customer shares one series ({} customers, {} invoices)",
                          customers.size(), invoices));
    }

    // ── the confirmation email ────────────────────────────────────────
    // Every paid order gets exactly one confirmation with the signed invoice
    // attached. The expected count comes from the LEDGER rather than a number
    // written here: "one per paid order" is the actual property, and a
    // literal would have to be edited by anyone who adds an order above — a
    // test that fails for the wrong reason and gets bumped without being
    // read. The mailer sweeps every 2 s.
    const std::size_t paidCount = CountOccurrences(srv.OrdersText(), "\"status\":\"paid\"");
    SettleUntil([&] { return MailCount(srv) >= paidCount; }, 60);
    const std::size_t mailCount = MailCount(srv);
    Check(mailCount == paidCount,
          std::format("one confirmation email per paid order ({} sent)", mailCount),
          std::format("expected {}", paidCount));

    // The NL order's message, found by its own order link (the same email
    // address placed two orders, so the address alone would be ambiguous).
    std::string nlMail;
    std::string gbMail;
    for (const auto& entry : std::filesystem::directory_iterator(srv.Work())) {
        const std::string name = entry.path().filename().string();
        if (!name.starts_with("mail-") || !name.ends_with(".eml")) continue;
        const std::string mail = ReadFile(entry.path());
        if (mail.find(std::format("/order/{}", token)) != std::string::npos) nlMail = mail;
        if (!tokenGb.empty()
            && mail.find(std::format("/order/{}", tokenGb)) != std::string::npos) {
            gbMail = mail;
        }
    }
    Check(!nlMail.empty(), "a confirmation email links the NL order");
    if (!nlMail.empty()) {
        for (std::string_view probe : { "To: e2e@example.org", "Subject: Catcrafts order CC-",
                                        "From: Catcrafts <info@catcrafts.net>",
                                        "MIME-Version: 1.0", "€578.30", "incl. 21% NL VAT",
                                        "KVK 78437059", "BEGIN PGP SIGNED MESSAGE",
                                        "filename=\"catcrafts-invoice-" }) {
            Check(nlMail.find(probe) != std::string::npos,
                  std::format("email has {}", probe));
        }
        // The attached invoice must verify offline exactly like the download.
        const std::size_t begin = nlMail.find("-----BEGIN PGP SIGNED MESSAGE-----");
        const std::size_t end = nlMail.find("-----END PGP SIGNATURE-----");
        Check(begin != std::string::npos && end != std::string::npos,
              "email carries a full PGP block");
        if (begin != std::string::npos && end != std::string::npos) {
            const std::filesystem::path file = srv.Work() / "mail-invoice.asc";
            WriteFile(file, nlMail.substr(
                begin, end + std::string_view("-----END PGP SIGNATURE-----").size() - begin)
                + "\n");
            Check(GpgVerifies(file), "emailed invoice signature verifies with gpg");
        }
    }
    // The export order's message states the VAT treatment its invoice carries.
    Check(!gbMail.empty() && gbMail.find("zero-rated export") != std::string::npos,
          "export confirmation states the zero-rated treatment");

    // Idempotency comes from the ledger's notified event, not from luck in
    // timing — sit out two more sweeps and expect no extra message.
    std::this_thread::sleep_for(std::chrono::seconds(5));
    Check(MailCount(srv) == mailCount, "no order was emailed twice",
          std::format("message count grew from {} to {}", mailCount, MailCount(srv)));
    Check(srv.OrdersText().find("\"type\":\"notified\"") != std::string::npos,
          "notified events recorded in the ledger");

    // ── financials reflect the ledger ─────────────────────────────────
    // Lifetime sales on /financials must equal the ledger: sum of total_minor
    // over orders that have a paid status event. Derived from the ledger
    // rather than written as a literal — same rule as the email count above:
    // "the page equals the ledger" is the actual property.
    {
        std::set<std::string> paidIds;
        std::int64_t wantMinor = 0;
        std::size_t wantCount = 0;
        const std::vector<std::string> lines = LedgerLines(srv);
        for (const std::string& line : lines) {
            const auto event = Json::Parse(line);
            if (!event || !event->IsObject()) continue;
            if (event->Str("type") == "status" && event->Str("status") == "paid") {
                paidIds.insert(std::string(event->Str("id")));
            }
        }
        for (const std::string& id : paidIds) {
            for (const std::string& line : lines) {
                const auto event = Json::Parse(line);
                if (!event || !event->IsObject()) continue;
                if (event->Str("type") == "order" && event->Str("id") == id) {
                    wantMinor += event->Int("total_minor");
                    ++wantCount;
                    break;
                }
            }
        }
        const std::string page = srv.Body("/financials");
        const std::string want = std::format(
            "data-fin-sales-minor=\"{}\"", wantMinor);
        Check(wantCount > 0 && page.find(want) != std::string::npos
                  && page.find(std::format("data-fin-sales-count=\"{}\"", wantCount))
                         != std::string::npos,
              std::format("sales totals equal the ledger ({} orders, {} cents)",
                          wantCount, wantMinor));
        // And the formatted euro figure for that total appears on the page.
        const std::string euro = wantMinor % 100 == 0
            ? std::format("€{}", wantMinor / 100)
            : std::format("€{}.{:02}", wantMinor / 100, wantMinor % 100);
        Check(page.find(euro) != std::string::npos,
              std::format("sales total renders as {}", euro));
    }
}

void ComingSoon(TestServer& srv) {
    // A perfectly valid order must be refused while the shop is closed: after
    // validation (so the field checks below still exercise the parser) and
    // before any rail or ledger is touched.
    srv.CheckStatus("/shop/fp6-pmos", "409", "POST", Good());
    Check(srv.OrdersText().empty(), "refused order writes nothing to the ledger");
    std::println("shop is coming-soon; the checkout, order-lifecycle and invoice "
                 "checks re-arm when the status flips to available");
}

void AlwaysOnValidation(TestServer& srv) {
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST",
                    "name=Ada&street=x&postal=1&city=y&country=NL");     // no email
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST",
                    "email=nonsense&" + Good());                          // bad email (dup keeps first)
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST",
                    "email=a%40b.example&country=NL");                    // missing address
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST", Good("&website=spam")); // honeypot

    // Destinations the shop refuses (Money::NoSaleCountries). Well-formed,
    // real addresses: the refusal is policy, not a shape check, so it has to
    // hold for every spelling the form accepts. Deliberately outside the
    // shop-open gate — validation runs before the coming-soon check, so this
    // must answer 422 whether the shop is open or not, and it is the
    // assertion that would catch the block being lost in a refactor.
    const std::size_t before = LedgerLines(srv).size();
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST",
        "email=us%40example.org&name=Pat&street=1%20Main%20St&postal=43004&city=Columbus&country=US");
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST",
        "email=ca%40example.org&name=Terry&street=1%20Bloor%20St&postal=M4W&city=Toronto&country=CA");
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST",
        "email=us%40example.org&name=Pat&street=1%20Main%20St&postal=43004&city=Columbus&country=us");
    // Sanctioned destinations (Money::SanctionedCountries) refuse through the
    // same always-on gate — this refusal is the law, so of all the checks in
    // this file it is the one that must survive every refactor.
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST",
        "email=ru%40example.org&name=Sasha&street=1%20Tverskaya&postal=125009&city=Moscow&country=RU");
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST",
        "email=by%40example.org&name=Vanya&street=1%20Kastrychnitskaya&postal=220030&city=Minsk&country=BY");
    srv.CheckStatus("/shop/fp6-pmos", "422", "POST",
        "email=ru%40example.org&name=Sasha&street=1%20Tverskaya&postal=125009&city=Moscow&country=ru");
    // Refused in validation means nothing reached the ledger and no payment
    // link was ever created.
    Check(LedgerLines(srv).size() == before, "a refused destination creates no order record");
    srv.CheckStatus("/shop/nope", "404", "POST", Good());  // unknown product
}

// The re-rendered form only exists when the shop is open; while coming-soon a
// rejection answers with the coming-soon page instead.
void RejectedFormEcho(TestServer& srv) {
    // A rejected submission must come back with the values still in it —
    // losing a filled-in form is how a sale gets abandoned.
    {
        const auto rejected = srv.Post("/shop/fp6-pmos",
            "email=bad&name=Ada&street=Main%201&postal=1234AB&city=Delft&country=NLD");
        for (std::string_view probe : { "value=\"bad\"", "value=\"NLD\"", "value=\"Ada\"",
                                        "value=\"Main 1\"", "value=\"Delft\"" }) {
            Check(rejected.body.find(probe) != std::string::npos,
                  std::format("rejected form preserves {}", probe));
        }
        Check(rejected.body.find("field__error") != std::string::npos,
              "rejected form shows a field error");
    }
    // A refused destination says why, in the form, with the address still in
    // it — the visitor should learn the shop does not sell there, not that
    // something went wrong.
    {
        const auto refused = srv.Post("/shop/fp6-pmos",
            "email=us%40example.org&name=Pat&street=1%20Main%20St&postal=43004&city=Columbus&country=US");
        Check(refused.body.find("does not sell or ship to the United States or Canada")
                  != std::string::npos,
              "refusal explains itself on the form");
        Check(refused.body.find("value=\"Pat\"") != std::string::npos,
              "a refused submission keeps what was typed");
    }
    // A sanctioned destination gets the sanctions sentence, not the policy
    // one — the buyer should learn the law forbids the sale, not wonder what
    // insurance has to do with Moscow.
    {
        const auto refused = srv.Post("/shop/fp6-pmos",
            "email=ru%40example.org&name=Sasha&street=1%20Tverskaya&postal=125009&city=Moscow&country=RU");
        Check(refused.body.find("EU sanctions prohibit") != std::string::npos,
              "sanctions refusal explains itself on the form");
        Check(refused.body.find("field__error\">Catcrafts does not sell") == std::string::npos,
              "sanctions refusal is not worded as the policy one");
    }
    // The buy panel warns before anyone fills it in, and the preview script
    // carries the same lists so it cannot quote a total the server would
    // refuse.
    srv.BodyHas("/shop/fp6-pmos", "does not sell or ship to the United States or Canada",
                "buy panel states where the shop does not sell");
    srv.BodyHas("/shop/fp6-pmos", "cannot sell or ship to Russia, Belarus or North Korea",
                "buy panel states where the law forbids selling");
    srv.BodyHas("/shop/fp6-pmos", "&quot;x&quot;:[&quot;US&quot;,&quot;CA&quot;]",
                "total preview knows the refused destinations");
    srv.BodyHas("/shop/fp6-pmos", "&quot;s&quot;:[&quot;RU&quot;,&quot;BY&quot;,&quot;KP&quot;]",
                "total preview knows the sanctioned destinations");
    // The honeypot message must not name the trap, or it teaches the next
    // bot. Only the ERROR NOTICE is inspected: the re-rendered form
    // legitimately contains the name="website" field itself — that IS the
    // trap, re-armed.
    {
        const auto pot = srv.Post("/shop/fp6-pmos", Good("&website=x"));
        std::smatch m;
        Check(std::regex_search(pot.body, m, std::regex(R"lit(notice--error">([^<]*))lit")),
              "honeypot rejection renders an error notice");
        if (!m.empty()) {
            std::string notice = m[1].str();
            for (char& c : notice) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
            const bool names = notice.find("honeypot") != std::string::npos
                               || notice.find("website") != std::string::npos
                               || notice.find("hidden") != std::string::npos
                               || notice.find("trap") != std::string::npos;
            Check(!names, "honeypot failure does not name the trap", m[1].str());
        }
    }
}

} // namespace

int main(int argc, char** argv) {
    ServerOptions options;
    options.gpg = true;
    options.mailer = true;
    TestServer srv(argv[1], 8217, options);

    if (srv.ShopOpen()) {
        OpenShopLifecycle(srv);
    } else {
        ComingSoon(srv);
    }

    AlwaysOnValidation(srv);

    if (srv.ShopOpen()) {
        RejectedFormEcho(srv);
    }

    return Finish();
}