// SPDX-License-Identifier: GPL-3.0-only #include "modern/ui/demo_almanac.hpp" #include #include #include #include #include #include #include namespace bmh::modern_ui { namespace { bool keys(const Json &v, std::initializer_list required, std::initializer_list optional = {}) { if (!v.is_object()) return false; std::set allowed; for (auto *key : required) { if (!v.contains(key)) return false; allowed.emplace(key); } for (auto *key : optional) allowed.emplace(key); for (const auto &entry : v.items()) if (!allowed.contains(entry.key())) return false; return true; } bool integer(const Json &v, int lo, int hi) { if (v.is_number_unsigned()) return hi >= 0 && v.get() <= uint64_t(hi) && (lo <= 0 || v.get() >= uint64_t(lo)); return v.is_number_integer() && v.get() >= lo && v.get() <= hi; } bool text(const Json &v, bool nonempty = true) { return v.is_string() && (!nonempty || !v.get_ref().empty()); } bool date(const std::string &iso) { if (iso.size() != 10 || iso[4] != '-' || iso[7] != '-') return false; for (size_t i = 0; i < iso.size(); ++i) if (i != 4 && i != 7 && (iso[i] < '0' || iso[i] > '9')) return false; const auto y = std::stoi(iso.substr(0, 4)), m = std::stoi(iso.substr(5, 2)), d = std::stoi(iso.substr(8, 2)); return y >= 1 && std::chrono::year_month_day{std::chrono::year{y}, std::chrono::month{unsigned(m)}, std::chrono::day{unsigned(d)}}.ok(); } std::string iso(int year, int month, int day) { std::ostringstream out; out.imbue(std::locale::classic()); out << std::setfill('0') << std::setw(4) << year << '-' << std::setw(2) << month << '-' << std::setw(2) << day; return out.str(); } std::string season(int year) { std::ostringstream out; out.imbue(std::locale::classic()); out << std::setfill('0') << std::setw(4) << year << '/' << std::setw(2) << (year + 1) % 100; return out.str(); } bool person(const Json &p, bool position = false) { return keys(p, {"id", "name"}, position ? std::initializer_list{"position"} : std::initializer_list{}) && text(p.at("id")) && text(p.at("name"), false) && (!p.contains("position") || text(p.at("position"))); } bool score(const Json &v) { return v.is_array() && v.size() == 2 && integer(v[0], 0, 99) && integer(v[1], 0, 99); } std::string position(const Json &p) { const auto found = p.find("positions"); if (found == p.end() || !found->is_array()) return ""; if (std::find(found->begin(), found->end(), "gk") != found->end()) return "gk"; for (const auto &v : *found) if (text(v)) return v.get(); return ""; } Json snapshot_player(const Catalog &world, const Json &p) { Json result = {{"id", p.at("id")}, {"name", world.name(p)}}; const auto role = position(p); if (!role.empty()) result["position"] = role; return result; } Json lineup(const Catalog &world, const std::string &club) { const auto players = world.squad(club); const Json *keeper = nullptr; std::vector outfield; for (auto *p : players) { if (position(*p) == "gk") { if (!keeper) keeper = p; } else outfield.push_back(p); } // A partial squad is missing information, never an invented starting XI. if (!keeper || outfield.size() < 10) return nullptr; Json starters = Json::array({snapshot_player(world, *keeper)}), bench = Json::array(); std::set selected{keeper->at("id").get()}; for (size_t i = 0; i < 10; ++i) { starters.push_back(snapshot_player(world, *outfield[i])); selected.emplace(outfield[i]->at("id").get()); } for (auto *p : players) if (!selected.contains(p->at("id").get())) bench.push_back(snapshot_player(world, *p)); return {{"starters", starters}, {"bench", bench}}; } Json actor(const Json &team, int index, bool bench = false) { if (team.is_null()) return nullptr; const auto &players = team.at(bench ? "bench" : "starters"); if (index < 0 || size_t(index) >= players.size()) return nullptr; const auto &p = players.at(size_t(index)); return {{"id", p.at("id")}, {"name", p.at("name")}}; } Json club_snapshot(const Catalog &world, const Json &club, int manager_index = -1) { Json manager = nullptr; if (manager_index >= 0) manager = {{"id", "demo:almanac:manager:" + std::to_string(manager_index)}, {"name", "Demo-Manager " + std::to_string(manager_index + 1)}}; Json crest = nullptr; if (club.contains("crest") && text(club.at("crest"))) crest = club.at("crest"); return {{"id", club.at("id")}, {"name", world.name(club)}, {"crest", crest}, {"manager", manager}}; } Json competition(const Catalog &world, const Json &home, const Json &away, bool cup) { if (!cup && home.value("competition", "") == away.value("competition", "")) { const auto *league = world.find("competitions", home.value("competition", "")); if (league && league->value("type", "") == "league") return {{"id", league->at("id")}, {"name", world.name(*league)}, {"type", "league"}}; } if (cup) for (const auto &c : world.rows("competitions")) if (c.value("type", "") == "cup") return {{"id", c.at("id")}, {"name", world.name(c)}, {"type", "cup"}}; return {{"id", cup ? "demo:competition:cup" : "demo:competition:friendly"}, {"name", cup ? "Demo-Pokal" : "Demo-Freundschaftsspiel"}, {"type", cup ? "cup" : "friendly"}}; } Json make_match(const Catalog &world, const Json &home, const Json &away, int year, int ordinal) { const std::array, 6> scores{{{3, 1}, {0, 0}, {2, 0}, {2, 1}, {2, 2}, {1, 2}}}; const auto [hg, ag] = scores[size_t(ordinal)]; const bool extra = ordinal == 3 || ordinal == 4, shootout = ordinal == 4; const auto day = ordinal < 3 ? iso(year, 8, 3) : ordinal == 3 ? iso(year, 12, 14) : ordinal == 4 ? iso(year + 1, 2, 20) : iso(year + 1, 5, 18); Json rosters = {{"home", lineup(world, home.at("id"))}, {"away", lineup(world, away.at("id"))}}; // Historical recording can be incomplete even when the current world has a squad. if (ordinal == 5) rosters["away"] = nullptr; Json events = Json::array(); const auto event = [&](const char *kind, int minute, const char *side, int index, int detail = 0, Json other = nullptr, bool bench = false) { events.push_back({{"kind", kind}, {"minute", minute}, {"side", side}, {"player", actor(rosters.at(side), index, bench)}, {"other", std::move(other)}, {"detail", detail}}); }; if (ordinal == 0) { event("miss", 6, "home", 1, 0); event("goal", 9, "home", 1, 0, actor(rosters.at("home"), 3)); event("goal", 18, "away", 1, 1); event("yellow", 23, "home", 2); event("miss", 25, "away", 3, 1); event("miss", 41, "home", 4, 2); event("injury", 49, "home", 5); if (!rosters.at("home").is_null() && !rosters["home"]["bench"].empty()) event("substitution", 50, "home", 0, 0, actor(rosters.at("home"), 5), true); else if (rosters.at("home").is_null()) event("substitution", 50, "home", -1); event("goal", 61, "home", 2, 2); event("red", 67, "away", 4); event("second_yellow", 72, "home", 2); event("miss", 79, "away", 6, 3); event("goal", 82, "home", 3, 3); } else if (ordinal == 1) { event("miss", 27, "home", 1, 1); event("yellow", 54, "away", 3); } else if (ordinal == 2) { event("goal", 29, "home", 2, 1); event("goal", 76, "home", 3, 0); } else if (extra) { event("goal", 19, "home", 1, 0); event("goal", 58, "away", 1, 3); event("goal", 103, "home", 2, 2); if (shootout) { event("goal", 117, "away", 2, 1); const std::array h{1, 1, 0, 1, 1}, a{1, 1, 0, 1, 0}; for (int i = 0; i < 5; ++i) { event("shootout", 121, "home", i + 1, h[size_t(i)]); event("shootout", 121, "away", i + 1, a[size_t(i)]); } } } else { event("goal", 12, "away", 1, 0); event("goal", 43, "home", 1, 3); event("goal", 88, "away", 2, 2); } return {{"id", "demo:almanac:" + std::to_string(year) + ":" + std::to_string(ordinal)}, {"date", day}, {"season", season(year)}, {"competition", competition(world, home, away, extra)}, {"round", ordinal + 1}, {"home", club_snapshot(world, home, ordinal == 0 ? 0 : -1)}, {"away", club_snapshot(world, away, ordinal == 0 ? 1 : -1)}, {"result", {{"regulation", extra ? Json::array({1, 1}) : Json::array({hg, ag})}, {"extra", extra ? Json::array({hg - 1, ag - 1}) : Json(nullptr)}, {"penalties", shootout ? Json::array({4, 3}) : Json(nullptr)}, {"final", {hg, ag}}, {"extra_played", extra}, {"penalties_played", shootout}}}, {"referee", ordinal == 5 ? Json(nullptr) : Json("Demo-Schiedsrichter " + std::to_string(ordinal % 3 + 1))}, {"attendance", ordinal == 5 ? Json(nullptr) : Json(ordinal == 1 ? 0 : 14500 + ordinal * 3275)}, {"weather", {{"temperature", ordinal == 5 ? Json(nullptr) : Json(ordinal == 1 ? 0 : ordinal == 4 ? 3 : 16 + ordinal)}, {"rain", ordinal == 5 ? Json(nullptr) : Json(ordinal == 1 ? 0 : ordinal % 8)}}}, {"lineups", rosters}, {"events", events}}; } bool valid_club(const Json &club) { return keys(club, {"id", "name", "crest", "manager"}) && text(club.at("id")) && text(club.at("name"), false) && (club.at("crest").is_null() || text(club.at("crest"))) && (club.at("manager").is_null() || person(club.at("manager"))); } struct Roster { bool known = false; std::map names; std::set active, bench, yellow, dismissed; }; bool valid_roster(const Json &value, Roster &out) { if (value.is_null()) return true; if (!keys(value, {"starters", "bench"}) || !value.at("starters").is_array() || value.at("starters").size() != 11 || !value.at("bench").is_array()) return false; out.known = true; int keepers = 0, unknown_positions = 0; for (const auto *key : {"starters", "bench"}) for (const auto &p : value.at(key)) { if (!person(p, true)) return false; const auto id = p.at("id").get(); if (!out.names.emplace(id, p.at("name").get()).second) return false; if (std::string(key) == "starters") { out.active.insert(id); if (!p.contains("position")) ++unknown_positions; if (p.value("position", "") == "gk") ++keepers; } else out.bench.insert(id); } return keepers == 1 || (keepers == 0 && unknown_positions > 0); } bool valid_match(const Json &m) { if (!keys(m, {"id", "date", "season", "competition", "round", "home", "away", "result", "referee", "attendance", "weather", "lineups", "events"}) || !text(m.at("id")) || !text(m.at("date")) || !date(m.at("date").get()) || !text(m.at("season")) || !integer(m.at("round"), 1, 999) || !valid_club(m.at("home")) || !valid_club(m.at("away")) || m.at("home").at("id") == m.at("away").at("id")) return false; const auto when = m.at("date").get(); const int year = std::stoi(when.substr(0, 4)) - (when.substr(5, 2) < "07" ? 1 : 0); if (year < 1 || m.at("season") != season(year)) return false; const auto &c = m.at("competition"), &r = m.at("result"), &w = m.at("weather"); if (!keys(c, {"id", "name", "type"}) || !text(c.at("id")) || !text(c.at("name"), false) || !text(c.at("type")) || !keys(r, {"regulation", "extra", "penalties", "final", "extra_played", "penalties_played"}) || !score(r.at("final")) || !r.at("extra_played").is_boolean() || !r.at("penalties_played").is_boolean() || !(r.at("regulation").is_null() || score(r.at("regulation"))) || !(r.at("extra").is_null() || score(r.at("extra"))) || !(r.at("penalties").is_null() || score(r.at("penalties"))) || !(m.at("referee").is_null() || text(m.at("referee"))) || !(m.at("attendance").is_null() || integer(m.at("attendance"), 0, 1000000)) || !keys(w, {"temperature", "rain"}) || !(w.at("temperature").is_null() || integer(w.at("temperature"), -100, 100)) || !(w.at("rain").is_null() || integer(w.at("rain"), 0, 7))) return false; const bool extra = r.at("extra_played"), penalties = r.at("penalties_played"); if ((!extra && !r.at("extra").is_null()) || (!extra && !r.at("regulation").is_null() && r.at("regulation") != r.at("final")) || (extra && !r.at("regulation").is_null() && r.at("regulation")[0] != r.at("regulation")[1]) || (penalties != !r.at("penalties").is_null()) || (penalties && (r.at("final")[0] != r.at("final")[1] || r.at("penalties")[0] == r.at("penalties")[1]))) return false; if (!keys(m.at("lineups"), {"home", "away"}) || !m.at("events").is_array()) return false; std::array rosters; if (!valid_roster(m.at("lineups").at("home"), rosters[0]) || !valid_roster(m.at("lineups").at("away"), rosters[1])) return false; for (const auto &[id, name] : rosters[0].names) { (void)name; if (rosters[1].names.contains(id)) return false; } std::array goals{}, regular{}, added{}, kicks{}, taken{}; int last_minute = 0, kick_count = 0, first_kicker = -1; bool decided = false; for (const auto &e : m.at("events")) { if (!keys(e, {"kind", "minute", "side", "player", "other", "detail"}) || !text(e.at("kind")) || !integer(e.at("minute"), 1, 121) || !(e.at("side") == "home" || e.at("side") == "away") || !(e.at("player").is_null() || person(e.at("player"))) || !(e.at("other").is_null() || person(e.at("other")))) return false; const auto kind = e.at("kind").get(); const bool kick = kind == "shootout", chance = kind == "goal" || kind == "miss"; if (!(chance || kick || kind == "yellow" || kind == "second_yellow" || kind == "red" || kind == "injury" || kind == "substitution") || !integer(e.at("detail"), 0, kick ? 1 : chance ? 3 : 0)) return false; const int minute = e.at("minute"), side = e.at("side") == "home" ? 0 : 1; if (minute < last_minute || (kick ? (!penalties || minute != 121) : minute > (extra ? 120 : 90))) return false; last_minute = minute; auto &roster = rosters[size_t(side)]; for (const auto *key : {"player", "other"}) { const auto &p = e.at(key); if (!p.is_null() && roster.known) { const auto found = roster.names.find(p.at("id").get()); if (found == roster.names.end() || found->second != p.at("name").get()) return false; } } const auto player = e.at("player").is_null() ? "" : e.at("player").at("id").get(); const auto other = e.at("other").is_null() ? "" : e.at("other").at("id").get(); if (!other.empty() && !chance && kind != "substitution") return false; if (roster.known) { if (kind == "substitution") { if (!player.empty() && other.empty() && roster.active.size() >= 11 - roster.dismissed.size()) return false; if (!player.empty() && !roster.bench.erase(player)) return false; if (!other.empty() && !roster.active.erase(other)) return false; if (!player.empty()) roster.active.insert(player); } else if ((!player.empty() && !roster.active.contains(player)) || (!other.empty() && (!roster.active.contains(other) || player == other))) return false; if (kind == "yellow" && !player.empty()) { if (!roster.yellow.insert(player).second) return false; } else if ((kind == "red" || kind == "second_yellow") && !player.empty()) { if (kind == "second_yellow" && !roster.yellow.contains(player)) return false; roster.active.erase(player); roster.dismissed.insert(player); } } if (kind == "goal") { ++goals[size_t(side)]; if (minute <= 90) ++regular[size_t(side)]; else ++added[size_t(side)]; } else if (kick) { if (first_kicker < 0) first_kicker = side; if (decided || side != (first_kicker + kick_count) % 2) return false; ++kick_count; ++taken[size_t(side)]; kicks[size_t(side)] += e.at("detail").get(); if (taken[0] <= 5 && taken[1] <= 5) decided = kicks[0] > kicks[1] + 5 - taken[1] || kicks[1] > kicks[0] + 5 - taken[0]; else if (taken[0] == taken[1]) decided = kicks[0] != kicks[1]; } } for (int side = 0; side < 2; ++side) { if (r.at("final")[size_t(side)] != goals[size_t(side)] || (!r.at("regulation").is_null() && r.at("regulation")[size_t(side)] != regular[size_t(side)]) || (!r.at("extra").is_null() && r.at("extra")[size_t(side)] != added[size_t(side)]) || (penalties && r.at("penalties")[size_t(side)] != kicks[size_t(side)])) return false; } return penalties ? decided : kick_count == 0; } Json error(const char *message) { return {{"ok", false}, {"error", message}}; } } // namespace Json make_demo_almanac(const Catalog &world) { Json archive = {{"schema", "openbmh-ui-demo-almanac@1"}, {"matches", Json::array()}}; const auto clubs = world.clubs(); if (clubs.size() < 2) return archive; const auto start = world.manifest().value("start_date", Json("2026-07-01")); if (!text(start) || !date(start.get())) return archive; const auto when = start.get(); const int current = std::stoi(when.substr(0, 4)) - (when.substr(5, 2) < "07" ? 1 : 0); if (current < 3) return archive; for (int year = current - 2; year < current; ++year) for (int ordinal = 0; ordinal < 6; ++ordinal) { const size_t pair = ordinal < 3 ? size_t(ordinal) * 2 : 0; const auto *home = clubs[pair % clubs.size()], *away = clubs[(pair + 1) % clubs.size()]; archive["matches"].push_back(make_match(world, *home, *away, year, ordinal)); } return archive; } bool valid_demo_almanac(const Json &archive) { try { if (!keys(archive, {"schema", "matches"}) || archive.at("schema") != "openbmh-ui-demo-almanac@1" || !archive.at("matches").is_array()) return false; std::set ids; for (const auto &m : archive.at("matches")) if (!valid_match(m) || !ids.insert(m.at("id").get()).second) return false; return true; } catch (const Json::exception &) { return false; } } Json query_demo_almanac(const Json &archive, const Json &request, const std::string &as_of) { if (!date(as_of)) return error("invalid_almanac_cutoff"); if (!valid_demo_almanac(archive)) return error("invalid_demo_almanac"); try { if (!request.is_object() || !request.contains("kind") || !text(request.at("kind"))) return error("invalid_almanac_request"); const auto kind = request.at("kind").get(); const bool index = kind == "index", calendar = kind == "calendar", day = kind == "day", match = kind == "match"; if (!(index || calendar || day || match) || !(index ? keys(request, {"kind"}) : calendar ? keys(request, {"kind", "year"}) : day ? keys(request, {"kind", "date"}) : keys(request, {"kind", "id"})) || (calendar && !integer(request.at("year"), 1, 9999)) || (day && (!text(request.at("date")) || !date(request.at("date").get()))) || (match && !text(request.at("id")))) return error("invalid_almanac_request"); std::vector visible; for (const auto &m : archive.at("matches")) if (m.at("date").get() <= as_of) visible.push_back(&m); std::stable_sort(visible.begin(), visible.end(), [](const auto *a, const auto *b) { return a->at("date").template get() < b->at("date").template get(); }); if (index) { std::set years; for (const auto *m : visible) years.insert(std::stoi(m->at("date").template get().substr(0, 4))); Json listed = Json::array(); for (int year : years) listed.push_back(year); return {{"ok", true}, {"years", listed}, {"match_count", visible.size()}, {"first_date", visible.empty() ? Json(nullptr) : visible.front()->at("date")}, {"last_date", visible.empty() ? Json(nullptr) : visible.back()->at("date")}}; } if (calendar) { const int year = request.at("year"); std::map days; for (const auto *m : visible) { const auto when = m->at("date").template get(); if (std::stoi(when.substr(0, 4)) != year) continue; auto [it, inserted] = days.try_emplace(when, Json{{"date", when}, {"count", 0}, {"highlights", Json::array()}}); (void)inserted; it->second["count"] = it->second.at("count").get() + 1; const auto &r = m->at("result"); if (r.at("extra_played") == true || r.at("penalties_played") == true || r.at("final")[0].get() + r.at("final")[1].get() >= 4) it->second["highlights"].push_back(m->at("id")); } Json listed = Json::array(); for (const auto &[when, item] : days) { (void)when; listed.push_back(item); } return {{"ok", true}, {"year", year}, {"days", listed}}; } if (day) { Json matches = Json::array(); for (const auto *m : visible) if (m->at("date") == request.at("date")) matches.push_back(*m); return {{"ok", true}, {"date", request.at("date")}, {"matches", matches}}; } for (const auto *m : visible) if (m->at("id") == request.at("id")) return {{"ok", true}, {"match", *m}}; return error("almanac_match_not_found"); } catch (const Json::exception &) { return error("invalid_almanac_request"); } } } // namespace bmh::modern_ui