5dplomacy/MultiversalDiplomacy/Model/Map.cs

namespace MultiversalDiplomacy.Model;

/// <summary>
/// Encapsulation of the world map and playable powers constituting a Diplomacy variant.
/// </summary>
public class Map
{
    /// <summary>
    /// The map type.
    /// </summary>
    public MapType Type { get; }

    /// <summary>
    /// The game map.
    /// </summary>
    public IReadOnlyCollection<Province> Provinces => _Provinces.AsReadOnly();

    private List<Province> _Provinces { get; }

    private Dictionary<string, Location> LocationLookup { get; }

    /// <summary>
    /// The game powers.
    /// </summary>
    public IReadOnlyCollection<string> Powers => _Powers.AsReadOnly();

    private List<string> _Powers { get; }

    private Map(MapType type, IEnumerable<Province> provinces, IEnumerable<string> powers)
    {
        Type = type;
        _Provinces = provinces.ToList();
        _Powers = powers.ToList();

        LocationLookup = Provinces
            .SelectMany(province => province.Locations)
            .ToDictionary(location => location.Key);
    }

    /// <summary>
    /// A regex that matches any of the power names for this variant.
    /// </summary>
    public string PowerRegex => $"({string.Join("|", Powers)})";

    /// <summary>
    /// A regex that matches any of the province names or abbreviations for this variant.
    /// </summary>
    public string ProvinceRegex => $"({string.Join("|", Provinces.SelectMany(p => p.AllNames))})";

    /// <summary>
    /// Get a province by name. Throws if the province is not found.
    /// </summary>
    public Province GetProvince(string provinceName)
        => GetProvince(provinceName, this.Provinces);

    /// <summary>
    /// Get a province by name. Throws if the province is not found.
    /// </summary>
    private static Province GetProvince(string provinceName, IEnumerable<Province> provinces)
        => provinces.SingleOrDefault(province => province!.Is(provinceName), null)
        ?? throw new KeyNotFoundException($"Province {provinceName} not found");

    /// <summary>
    /// Get the location in a province matching a predicate. Throws if there is not exactly one
    /// such location.
    /// </summary>
    private Location GetLocation(string provinceName, Func<Location, bool> predicate)
        => GetProvince(provinceName).Locations.SingleOrDefault(
            l => l != null && predicate(l), null)
            ?? throw new KeyNotFoundException($"No such location in {provinceName}");

    public Location GetLocation(string designation)
        => LocationLookup[designation];

    public Location GetLocation(Unit unit)
        => GetLocation(unit.Location);

    /// <summary>
    /// Get the sole land location of a province.
    /// </summary>
    public Location GetLand(string provinceName)
        => GetLocation(provinceName, l => l.Type == LocationType.Land);

    /// <summary>
    /// Get the sole water location of a province, optionally specifying a named coast.
    /// </summary>
    public Location GetWater(string provinceName, string? coastName = null)
        => coastName == null
            ? GetLocation(provinceName, l => l.Type == LocationType.Water)
            : GetLocation(provinceName, l => l.Name == coastName || l.Abbreviation == coastName);

    /// <summary>
    /// Get a power by full or partial name. Throws if there is not exactly one such power.
    /// </summary>
    public string GetPower(string powerName)
        => Powers.SingleOrDefault(p => p!.EqualsAnyCase(powerName) || p!.StartsWithAnyCase(powerName), null)
            ?? throw new KeyNotFoundException($"Power {powerName} not found (powers: {string.Join(", ", Powers)})");

    public static Map FromType(MapType type)
        => type switch {
            MapType.Test => Test,
            MapType.Classical => Classical,
            _ => throw new NotImplementedException($"Unknown variant {type}"),
        };

    public static Map Test => _Test.Value;

    private static readonly Lazy<Map> _Test = new(() => {
        Province lef = Province.Time("Left", "Lef")
            .AddLandLocation();
        Province cen = Province.Empty("Center", "Cen")
            .AddLandLocation();
        Province rig = Province.Time("Right", "Rig")
            .AddLandLocation();
        Location center = cen.Locations.First();
        center.AddBorder(lef.Locations.First());
        center.AddBorder(rig.Locations.First());

        return new(MapType.Test, [lef, cen, rig], ["Alpha", "Beta"]);
    });

    public static Map Classical => _Classical.Value;

    private static readonly Lazy<Map> _Classical = new(() => {
        // Define the provinces of the standard world map.
        List<Province> provinces =
        [
#region Provinces
            Province.Empty("North Africa", "NAF")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Tunis", "TUN")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Bohemia", "BOH")
                .AddLandLocation(),
            Province.Supply("Budapest", "BUD")
                .AddLandLocation(),
            Province.Empty("Galacia", "GAL")
                .AddLandLocation(),
            Province.Supply("Trieste", "TRI")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Tyrolia", "TYR")
                .AddLandLocation(),
            Province.Time("Vienna", "VIE")
                .AddLandLocation(),
            Province.Empty("Albania", "ALB")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Bulgaria", "BUL")
                .AddLandLocation()
                .AddCoastLocation("east coast", "ec")
                .AddCoastLocation("south coast", "sc"),
            Province.Supply("Greece", "GRE")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Rumania", "RUM", "RMA")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Serbia", "SER")
                .AddLandLocation(),
            Province.Empty("Clyde", "CLY")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Edinburgh", "EDI")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Liverpool", "LVP", "LPL")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Time("London", "LON")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Wales", "WAL")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Yorkshire", "YOR")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Brest", "BRE")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Burgundy", "BUR")
                .AddLandLocation(),
            Province.Empty("Gascony", "GAS")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Marseilles", "MAR")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Time("Paris", "PAR")
                .AddLandLocation(),
            Province.Empty("Picardy", "PIC")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Time("Berlin", "BER")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Kiel", "KIE")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Munich", "MUN")
                .AddLandLocation(),
            Province.Empty("Prussia", "PRU")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Ruhr", "RUH", "RHR")
                .AddLandLocation(),
            Province.Empty("Silesia", "SIL")
                .AddLandLocation(),
            Province.Supply("Spain", "SPA")
                .AddLandLocation()
                .AddCoastLocation("north coast", "nc")
                .AddCoastLocation("south coast", "sc"),
            Province.Supply("Portugal", "POR")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Apulia", "APU")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Naples", "NAP")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Piedmont", "PIE")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Time("Rome", "ROM", "RME")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Tuscany", "TUS")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Venice", "VEN")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Belgium", "BEL")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Holland", "HOL")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Finland", "FIN")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Livonia", "LVN", "LVA")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Time("Moscow", "MOS")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Sevastopol", "SEV")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Saint Petersburg", "STP")
                .AddLandLocation()
                .AddCoastLocation("north coast", "nc")
                .AddCoastLocation("west coast", "wc"),
            Province.Empty("Ukraine", "UKR")
                .AddLandLocation(),
            Province.Supply("Warsaw", "WAR")
                .AddLandLocation(),
            Province.Supply("Denmark", "DEN")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Norway", "NWY")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Sweden", "SWE")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Ankara", "ANK")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Armenia", "ARM")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Time("Constantinople", "CON")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Supply("Smyrna", "SMY")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Syria", "SYR")
                .AddLandLocation()
                .AddOceanLocation(),
            Province.Empty("Barents Sea", "BAR")
                .AddOceanLocation(),
            Province.Empty("English Channel", "ENC", "ECH")
                .AddOceanLocation(),
            Province.Empty("Heligoland Bight", "HEL", "HGB")
                .AddOceanLocation(),
            Province.Empty("Irish Sea", "IRS", "IRI")
                .AddOceanLocation(),
            Province.Empty("Mid-Atlantic Ocean", "MAO", "MID")
                .AddOceanLocation(),
            Province.Empty("North Atlantic Ocean", "NAO", "NAT")
                .AddOceanLocation(),
            Province.Empty("North Sea", "NTH", "NTS")
                .AddOceanLocation(),
            Province.Empty("Norwegian Sea", "NWS", "NWG")
                .AddOceanLocation(),
            Province.Empty("Skagerrak", "SKA", "SKG")
                .AddOceanLocation(),
            Province.Empty("Baltic Sea", "BAL")
                .AddOceanLocation(),
            Province.Empty("Guld of Bothnia", "GOB", "BOT")
                .AddOceanLocation(),
            Province.Empty("Adriatic Sea", "ADS", "ADR")
                .AddOceanLocation(),
            Province.Empty("Aegean Sea", "AEG")
                .AddOceanLocation(),
            Province.Empty("Black Sea", "BLA")
                .AddOceanLocation(),
            Province.Empty("Eastern Mediterranean Sea", "EMS", "EAS")
                .AddOceanLocation(),
            Province.Empty("Gulf of Lyons", "GOL", "LYO")
                .AddOceanLocation(),
            Province.Empty("Ionian Sea", "IOS", "ION", "INS")
                .AddOceanLocation(),
            Province.Empty("Tyrrhenian Sea", "TYS", "TYN")
                .AddOceanLocation(),
            Province.Empty("Western Mediterranean Sea", "WMS", "WES")
                .AddOceanLocation(),
#endregion
        ];

        // Declare some helpers for border definitions
        Location Land(string provinceName) => GetProvince(provinceName, provinces)
            .Locations.Single(l => l.Type == LocationType.Land);
        Location Water(string provinceName) => GetProvince(provinceName, provinces)
            .Locations.Single(l => l.Type == LocationType.Water);
        Location Coast(string provinceName, string coastName)
            => GetProvince(provinceName, provinces)
                .Locations.Single(l => l.Name == coastName || l.Abbreviation == coastName);

        static void AddBordersTo(Location location, Func<string, Location> LocationType, params string[] borders)
        {
            foreach (string bordering in borders)
            {
                location.AddBorder(LocationType(bordering));
            }
        }
        void AddBorders(string provinceName, Func<string, Location> LocationType, params string[] borders)
            => AddBordersTo(LocationType(provinceName), LocationType, borders);

#region Borders
        AddBorders("NAF", Land, "TUN");
        AddBorders("NAF", Water, "MAO", "WES", "TUN");

        AddBorders("TUN", Land, "NAF");
        AddBorders("TUN", Water, "NAF", "WES", "TYS", "ION");

        AddBorders("BOH", Land, "MUN", "SIL", "GAL", "VIE", "TYR");

        AddBorders("BUD", Land, "VIE", "GAL", "RUM", "SER", "TRI");

        AddBorders("GAL", Land, "BOH", "SIL", "WAR", "UKR", "RUM", "BUD", "VIE");

        AddBorders("TRI", Land, "TYR", "VIE", "BUD", "SER", "ALB");
        AddBorders("TRI", Water, "ALB", "ADR", "VEN");

        AddBorders("TYR", Land, "MUN", "BOH", "VIE", "TRI", "VEN", "PIE");

        AddBorders("VIE", Land, "TYR", "BOH", "GAL", "BUD", "TRI");

        AddBorders("ALB", Land, "TRI", "SER", "GRE");
        AddBorders("ALB", Water, "TRI", "ADR", "ION", "GRE");

        AddBorders("BUL", Land, "GRE", "SER", "RUM", "CON");
        AddBordersTo(Coast("BUL", "ec"), Water, "BLA", "CON");
        AddBordersTo(Coast("BUL", "sc"), Water, "CON", "AEG", "GRE");

        AddBorders("GRE", Land, "ALB", "SER", "BUL");
        AddBorders("GRE", Water, "ALB", "ION", "AEG");
        Water("GRE").AddBorder(Coast("BUL", "sc"));

        AddBorders("RUM", Land, "BUL", "SER", "BUD", "GAL", "UKR", "SEV");
        AddBorders("RUM", Water, "SEV", "BLA");
        Water("RUM").AddBorder(Coast("BUL", "ec"));

        AddBorders("SER", Land, "BUD", "RUM", "BUL", "GRE", "ALB", "TRI");

        AddBorders("CLY", Land, "EDI", "LVP");
        AddBorders("CLY", Water, "LVP", "NAO", "NWG", "EDI");

        AddBorders("EDI", Land, "YOR", "LVP", "CLY");
        AddBorders("EDI", Water, "CLY", "NWG", "NTH", "YOR");

        AddBorders("LVP", Land, "CLY", "EDI", "YOR", "WAL");
        AddBorders("LVP", Water, "WAL", "IRS", "NAO", "CLY");

        AddBorders("LON", Land, "WAL", "YOR");
        AddBorders("LON", Water, "WAL", "ENC", "NTH", "YOR");

        AddBorders("WAL", Land, "LVP", "YOR", "LON");
        AddBorders("WAL", Water, "LON", "ENC", "IRS", "LVP");

        AddBorders("YOR", Land, "LON", "WAL", "LVP", "EDI");
        AddBorders("YOR", Water, "EDI", "NTH", "LON");

        AddBorders("BRE", Land, "PIC", "PAR", "GAS");
        AddBorders("BRE", Water, "GAS", "MAO", "ENC", "PIC");

        AddBorders("BUR", Land, "BEL", "RUH", "MUN", "MAR", "GAS", "PAR", "PIC");

        AddBorders("GAS", Land, "BRE", "PAR", "BUR", "MAR", "SPA");
        AddBorders("GAS", Water, "MAO", "BRE");
        Water("GAS").AddBorder(Coast("SPA", "nc"));

        AddBorders("MAR", Land, "SPA", "GAS", "BUR", "PIE");
        AddBorders("MAR", Water, "LYO", "PIE");
        Water("MAR").AddBorder(Coast("SPA", "sc"));

        AddBorders("PAR", Land, "PIC", "BUR", "GAS", "BRE");

        AddBorders("PIC", Land, "BEL", "BUR", "PAR", "BRE");
        AddBorders("PIC", Water, "BRE", "ENC", "BEL");

        AddBorders("BER", Land, "PRU", "SIL", "MUN", "KIE");
        AddBorders("BER", Water, "KIE", "BAL", "PRU");

        AddBorders("KIE", Land, "BER", "MUN", "RUH", "HOL", "DEN");
        AddBorders("KIE", Water, "HOL", "HEL", "DEN", "BAL", "BER");

        AddBorders("MUN", Land, "BUR", "RUH", "KIE", "BER", "SIL", "BOH", "TYR");

        AddBorders("PRU", Land, "LVN", "WAR", "SIL", "BER");
        AddBorders("PRU", Water, "BER", "BAL", "LVN");

        AddBorders("RUH", Land, "KIE", "MUN", "BUR", "BEL", "HOL");

        AddBorders("SIL", Land, "PRU", "WAR", "GAL", "BOH", "MUN", "BER");

        AddBorders("SPA", Land, "POR", "GAS", "MAR");
        AddBordersTo(Coast("SPA", "nc"), Water, "POR", "MAO", "GAS");
        AddBordersTo(Coast("SPA", "sc"), Water, "POR", "MAO", "WES", "LYO", "MAR");

        AddBorders("POR", Land, "SPA");
        AddBorders("POR", Water, "MAO");
        Water("POR").AddBorder(Coast("SPA", "nc"));
        Water("POR").AddBorder(Coast("SPA", "sc"));

        AddBorders("APU", Land, "NAP", "ROM", "VEN");
        AddBorders("APU", Water, "VEN", "ADR", "IOS", "NAP");

        AddBorders("NAP", Land, "ROM", "APU");
        AddBorders("NAP", Water, "APU", "IOS", "TYS", "ROM");

        AddBorders("PIE", Land, "MAR", "TYR", "VEN", "TUS");
        AddBorders("PIE", Water, "TUS", "LYO", "MAR");

        AddBorders("ROM", Land, "TUS", "VEN", "APU", "NAP");
        AddBorders("ROM", Water, "NAP", "TYS", "TUS");

        AddBorders("TUS", Land, "PIE", "VEN", "ROM");
        AddBorders("TUS", Water, "ROM", "TYS", "LYO", "PIE");

        AddBorders("VEN", Land, "APU", "ROM", "TUS", "PIE", "TYR", "TRI");
        AddBorders("VEN", Water, "TRI", "ADR", "APU");

        AddBorders("BEL", Land, "HOL", "RUH", "BUR", "PIC");
        AddBorders("BEL", Water, "PIC", "ENC", "NTH", "HOL");

        AddBorders("HOL", Land, "BEL", "RUH", "KIE");
        AddBorders("HOL", Water, "NTH", "HEL");

        AddBorders("FIN", Land, "SWE", "NWY", "STP");
        AddBorders("FIN", Water, "SWE", "BOT");
        Water("FIN").AddBorder(Coast("STP", "wc"));

        AddBorders("LVN", Land, "STP", "MOS", "WAR", "PRU");
        AddBorders("LVN", Water, "PRU", "BAL", "BOT");
        Water("LVN").AddBorder(Coast("STP", "wc"));

        AddBorders("MOS", Land, "SEV", "UKR", "WAR", "LVN", "STP");

        AddBorders("SEV", Land, "RUM", "UKR", "MOS", "ARM");
        AddBorders("SEV", Water, "ARM", "BLA", "RUM");

        AddBorders("STP", Land, "MOS", "LVN", "FIN");
        AddBordersTo(Coast("STP", "nc"), Water, "BAR", "NWY");
        AddBordersTo(Coast("STP", "wc"), Water, "LVN", "BOT", "FIN");

        AddBorders("UKR", Land, "MOS", "SEV", "RUM", "GAL", "WAR");

        AddBorders("WAR", Land, "PRU", "LVN", "MOS", "UKR", "GAL", "SIL");

        AddBorders("DEN", Land, "KIE", "SWE");
        AddBorders("DEN", Water, "KIE", "HEL", "NTH", "SKA", "BAL", "SWE");

        AddBorders("NWY", Land, "STP", "FIN", "SWE");
        AddBorders("NWY", Water, "BAR", "NWG", "NTH", "SKA", "SWE");
        Water("NWY").AddBorder(Coast("STP", "nc"));

        AddBorders("SWE", Land, "NWY", "FIN", "DEN");
        AddBorders("SWE", Water, "FIN", "BOT", "BAL", "DEN", "SKA", "NWY");

        AddBorders("ANK", Land, "ARM", "SMY", "CON");
        AddBorders("ANK", Water, "CON", "BLA", "ARM");

        AddBorders("ARM", Land, "SEV", "SYR", "SMY", "ANK");
        AddBorders("ARM", Water, "ANK", "BLA", "SEV");

        AddBorders("CON", Land, "BUL", "ANK", "SMY");
        AddBorders("CON", Water, "BLA", "ANK", "SMY", "AEG");
        Water("CON").AddBorder(Coast("BUL", "ec"));
        Water("CON").AddBorder(Coast("BUL", "sc"));

        AddBorders("SMY", Land, "CON", "ANK", "ARM", "SYR");
        AddBorders("SMY", Water, "SYR", "EAS", "AEG", "CON");

        AddBorders("SYR", Land, "SMY", "ARM");
        AddBorders("SYR", Water, "EAS", "SMY");

        AddBorders("BAR", Water, "NWG", "NWY");
        Water("BAR").AddBorder(Coast("STP", "nc"));

        AddBorders("ENC", Water, "LON", "NTH", "BEL", "PIC", "BRE", "MAO", "IRS", "WAL");

        AddBorders("HEL", Water, "NTH", "DEN", "BAL", "KIE", "HOL");

        AddBorders("IRS", Water, "NAO", "LVP", "WAL", "ENC", "MAO");

        AddBorders("MAO", Water, "NAO", "IRS", "ENC", "BRE", "GAS", "POR", "NAF");
        Water("MAO").AddBorder(Coast("SPA", "nc"));
        Water("MAO").AddBorder(Coast("SPA", "sc"));

        AddBorders("NAO", Water, "NWG", "CLY", "LVP", "IRS", "MAO");

        AddBorders("NTH", Water, "NWG", "NWY", "SKA", "DEN", "HEL", "HOL", "BEL", "ENC", "LON", "YOR", "EDI");

        AddBorders("NWG", Water, "BAR", "NWY", "NTH", "EDI", "CLY", "NAO");

        AddBorders("SKA", Water, "NWY", "SWE", "BAL", "DEN", "NTH");

        AddBorders("BAL", Water, "BOT", "LVN", "PRU", "BER", "KIE", "HEL", "DEN", "SWE");

        AddBorders("BOT", Water, "LVN", "BAL", "SWE", "FIN");
        Water("BOT").AddBorder(Coast("STP", "wc"));

        AddBorders("ADR", Water, "IOS", "APU", "VEN", "TRI", "ALB");

        AddBorders("AEG", Water, "CON", "SMY", "EAS", "IOS", "GRE");
        Water("AEG").AddBorder(Coast("BUL", "sc"));

        AddBorders("BLA", Water, "RUM", "SEV", "ARM", "ANK", "CON");
        Water("BLA").AddBorder(Coast("BUL", "ec"));

        AddBorders("EAS", Water, "IOS", "AEG", "SMY", "SYR");

        AddBorders("LYO", Water, "MAR", "PIE", "TUS", "TYS", "WES");
        Water("LYO").AddBorder(Coast("SPA", "sc"));

        AddBorders("IOS", Water, "TUN", "TYS", "NAP", "APU", "ADR", "ALB", "GRE", "AEG");

        AddBorders("TYS", Water, "LYO", "TUS", "ROM", "NAP", "IOS", "TUN", "WES");

        AddBorders("WES", Water, "LYO", "TYS", "TUN", "NAF", "MAO");
        Water("WES").AddBorder(Coast("SPA", "sc"));
#endregion

        List<string> powers =
        [
            "Austria",
            "England",
            "France",
            "Germany",
            "Italy",
            "Russia",
            "Turkey",
        ];

        return new(MapType.Classical, provinces, powers);
    });
}