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<Power> Powers => _Powers.AsReadOnly();

    private List<Power> _Powers { get; }

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

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

    /// <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(
            p => p!.Name.Equals(provinceName, StringComparison.InvariantCultureIgnoreCase)
                || p.Abbreviations.Any(
                    a => a.Equals(provinceName, StringComparison.InvariantCultureIgnoreCase)),
            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 name. Throws if there is not exactly one such power.
    /// </summary>
    public Power GetPower(string powerName)
        => Powers.SingleOrDefault(p => p!.Name == powerName || p.Name.StartsWith(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());

        Power a = new("Alpha");
        Power b = new("Beta");

        return new(MapType.Test, [lef, cen, rig], [a, b]);
    });

    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<Power> powers =
        [
            new("Austria"),
            new("England"),
            new("France"),
            new("Germany"),
            new("Italy"),
            new("Russia"),
            new("Turkey"),
        ];

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