using System.Text.Json.Serialization;

namespace MultiversalDiplomacy.Model;

/// <summary>
/// The global game state.
/// </summary>
public class World
{
    /// <summary>
    /// The map variant of the game.
    /// </summary>
    [JsonIgnore]
    public Map Map { get; }

    /// <summary>
    /// The map variant of the game.
    /// </summary>
    /// <remarks>
    /// While this is serialized to JSON, deserialization uses it to populate <see cref="Map"/>
    /// </remarks>
    public MapType MapType => this.Map.Type;

    /// <summary>
    /// The game map.
    /// </summary>
    [JsonIgnore]
    public IReadOnlyCollection<Province> Provinces => this.Map.Provinces;

    /// <summary>
    /// The game powers.
    /// </summary>
    [JsonIgnore]
    public IReadOnlyCollection<Power> Powers => this.Map.Powers;

    /// <summary>
    /// The state of the multiverse.
    /// </summary>
    public List<Season> Seasons { get; }

    /// <summary>
    /// Lookup for seasons by designation.
    /// </summary>
    [JsonIgnore]
    public Dictionary<string, Season> SeasonLookup { get; }

    /// <summary>
    /// The first season of the game.
    /// </summary>
    [JsonIgnore]
    public Season RootSeason => GetSeason("a0");

    /// <summary>
    /// All units in the multiverse.
    /// </summary>
    public List<Unit> Units { get; }

    /// <summary>
    /// All retreating units in the multiverse.
    /// </summary>
    public List<RetreatingUnit> RetreatingUnits { get; }

    /// <summary>
    /// Orders given to units in each season.
    /// </summary>
    public Dictionary<string, OrderHistory> OrderHistory { get; }

    /// <summary>
    /// The shared timeline number generator.
    /// </summary>
    public TimelineFactory Timelines { get; }

    /// <summary>
    /// Immutable game options.
    /// </summary>
    public Options Options { get; }

    [JsonConstructor]
    public World(
        MapType mapType,
        List<Season> seasons,
        List<Unit> units,
        List<RetreatingUnit> retreatingUnits,
        Dictionary<string, OrderHistory> orderHistory,
        TimelineFactory timelines,
        Options options)
    {
        this.Map = Map.FromType(mapType);
        this.Seasons = seasons;
        this.Units = units;
        this.RetreatingUnits = retreatingUnits;
        this.OrderHistory = orderHistory;
        this.Timelines = timelines;
        this.Options = options;

        this.SeasonLookup = new(Seasons.ToDictionary(season => $"{season.Timeline}{season.Turn}"));
    }

    /// <summary>
    /// Create a new World, providing all state data.
    /// </summary>
    private World(
        Map map,
        List<Season> seasons,
        List<Unit> units,
        List<RetreatingUnit> retreatingUnits,
        Dictionary<string, OrderHistory> orderHistory,
        TimelineFactory timelines,
        Options options)
    {
        this.Map = map;
        this.Seasons = seasons;
        this.Units = units;
        this.RetreatingUnits = retreatingUnits;
        this.OrderHistory = orderHistory;
        this.Timelines = timelines;
        this.Options = options;

        this.SeasonLookup = new(Seasons.ToDictionary(season => $"{season.Timeline}{season.Turn}"));
    }

    /// <summary>
    /// Create a new World from a previous one, replacing some state data.
    /// </summary>
    private World(
        World previous,
        List<Season>? seasons = null,
        List<Unit>? units = null,
        List<RetreatingUnit>? retreatingUnits = null,
        Dictionary<string, OrderHistory>? orderHistory = null,
        Options? options = null)
        : this(
            previous.Map,
            seasons ?? previous.Seasons,
            units ?? previous.Units,
            retreatingUnits ?? previous.RetreatingUnits,
            orderHistory ?? previous.OrderHistory,
            previous.Timelines,
            options ?? previous.Options)
    {
    }

    /// <summary>
    /// Create a new world with specified provinces and powers and an initial season.
    /// </summary>
    public static World WithMap(Map map)
    {
        TimelineFactory timelines = new();
        return new World(
            map,
            new([new(past: null, Season.FIRST_TURN, timelines.NextTimeline())]),
            new([]),
            new([]),
            new(new Dictionary<string, OrderHistory>()),
            timelines,
            new Options());
    }

    /// <summary>
    /// Create a new world with the standard Diplomacy provinces and powers.
    /// </summary>
    public static World WithStandardMap()
        => WithMap(Map.Classical);

    public World Update(
        IEnumerable<Season>? seasons = null,
        IEnumerable<Unit>? units = null,
        IEnumerable<RetreatingUnit>? retreats = null,
        IEnumerable<KeyValuePair<string, OrderHistory>>? orders = null)
        => new(
            previous: this,
            seasons: seasons == null
                ? this.Seasons
                : new(seasons.ToList()),
            units: units == null
                ? this.Units
                : new(units.ToList()),
            retreatingUnits: retreats == null
                ? this.RetreatingUnits
                : new(retreats.ToList()),
            orderHistory: orders == null
                ? this.OrderHistory
                : new(orders.ToDictionary(kvp => kvp.Key, kvp => kvp.Value)));

    /// <summary>
    /// Create a new world with new units created from unit specs. Units specs are in the format
    /// "<power> <A/F> <province> [<coast>]". If the province or coast name has a space in it, the
    /// abbreviation should be used. Unit specs always describe units in the root season.
    /// </summary>
    public World AddUnits(params string[] unitSpecs)
    {
        IEnumerable<Unit> units = unitSpecs.Select(spec =>
        {
            string[] splits = spec.Split(' ', 4);
            Power power = Map.GetPower(splits[0]);
            UnitType type = splits[1] switch
            {
                "A" => UnitType.Army,
                "F" => UnitType.Fleet,
                _ => throw new ApplicationException($"Unknown unit type {splits[1]}")
            };
            Location location = type == UnitType.Army
                ? Map.GetLand(splits[2])
                : splits.Length == 3
                    ? Map.GetWater(splits[2])
                    : Map.GetWater(splits[2], splits[3]);
            Unit unit = Unit.Build(location.Designation, this.RootSeason, power, type);
            return unit;
        });
        return this.Update(units: units);
    }

    /// <summary>
    /// Create a new world with standard Diplomacy initial unit placements.
    /// </summary>
    public World AddStandardUnits()
    {
        return this.AddUnits(
            "Austria A Bud",
            "Austria A Vir",
            "Austria F Tri",
            "England A Lvp",
            "England F Edi",
            "England F Lon",
            "France A Mar",
            "France A Par",
            "France F Bre",
            "Germany A Ber",
            "Germany A Mun",
            "Germany F Kie",
            "Italy A Rom",
            "Italy A Ven",
            "Italy F Nap",
            "Russia A Mos",
            "Russia A War",
            "Russia F Sev",
            "Russia F Stp wc",
            "Turkey A Con",
            "Turkey A Smy",
            "Turkey F Ank"
        );
    }

    /// <summary>
    /// Create a continuation of this season if it has no futures, otherwise create a fork.
    /// </summary>
    public Season ContinueOrFork(Season season)
        => GetFutures(season).Any()
        ? new(season.Designation, season.Turn + 1, Timelines.NextTimeline())
        : new(season.Designation, season.Turn + 1, season.Timeline);

    /// <summary>
    /// A standard Diplomacy game setup.
    /// </summary>
    public static World Standard => WithStandardMap().AddStandardUnits();

    /// <summary>
    /// Get a season by coordinate. Throws if the season is not found.
    /// </summary>
    public Season GetSeason(string timeline, int turn)
        => GetSeason($"{timeline}{turn}");

    /// <summary>
    /// Get a season by designation.
    /// </summary>
    public Season GetSeason(string designation)
        => SeasonLookup[designation];

    /// <summary>
    /// Get all seasons that are immediate futures of a season.
    /// </summary>
    /// <param name="present">A season designation.</param>
    /// <returns>The immediate futures of the designated season.</returns>
    public IEnumerable<Season> GetFutures(string present)
        => Seasons.Where(future => future.Past == present);

    /// <summary>
    /// Get all seasons that are immediate futures of a season.
    /// </summary>
    /// <param name="present">A season.</param>
    /// <returns>The immediate futures of the season.</returns>
    public IEnumerable<Season> GetFutures(Season present) => GetFutures(present.Designation);

    /// <summary>
    /// Returns the first season in this season's timeline. The first season is the
    /// root of the first timeline. The earliest season in each alternate timeline is
    /// the root of that timeline.
    /// </summary>
    public Season GetTimelineRoot(Season season)
    {
        if (season.Past is null) {
            return season;
        }
        Season past = SeasonLookup[season.Past];
        return season.Timeline == past.Timeline
            ? GetTimelineRoot(past)
            : season;
    }

    /// <summary>
    /// Returns whether this season is in an adjacent timeline to another season.
    /// Seasons are considered to be in adjacent timelines if they are in the same timeline,
    /// one is in a timeline that branched from the other's timeline, or both are in timelines
    /// that branched from the same point.
    /// </summary>
    public bool InAdjacentTimeline(Season one, Season two)
    {
        // Timelines are adjacent to themselves. Early out in that case.
        if (one == two) return true;

        // If the timelines aren't identical, one of them isn't the initial trunk.
        // They can still be adjacent if one of them branched off of the other, or
        // if they both branched off of the same point.
        Season rootOne = GetTimelineRoot(one);
        Season rootTwo = GetTimelineRoot(two);
        bool oneForked = rootOne.Past != null && GetSeason(rootOne.Past).Timeline == two.Timeline;
        bool twoForked = rootTwo.Past != null && GetSeason(rootTwo.Past).Timeline == one.Timeline;
        bool bothForked = rootOne.Past == rootTwo.Past;
        return oneForked || twoForked || bothForked;
    }

    /// <summary>
    /// Returns a unit in a province. Throws if there are duplicate units.
    /// </summary>
    public Unit GetUnitAt(string provinceName, Season? season = null)
    {
        Province province = Map.GetProvince(provinceName);
        season ??= RootSeason;
        Unit? foundUnit = this.Units.SingleOrDefault(
            u => Map.GetLocation(u!).Province == province && u!.Season == season,
            null)
            ?? throw new KeyNotFoundException($"Unit at {province} at {season} not found");
        return foundUnit;
    }

    public Unit GetUnitByDesignation(string designation)
        => Units.SingleOrDefault(u => u!.Designation == designation, null)
        ?? throw new KeyNotFoundException($"Unit {designation} not found");
}