using System;
using System.Collections.Generic;

namespace Bogatyri.World
{
    public enum MarchState
    {
        Outbound,  // идут к цели
        Returning, // бой прошёл, возвращаются домой
        Finished,  // вернулись, солдаты и добыча зачислены
        Gathering  // стоят на ресурсной точке и собирают (регламент 31.10)
    }

    // Один поход. Всё время -- абсолютное (Unix-время в миллисекундах), а не "осталось N секунд":
    // поход продолжается, пока игра закрыта, и одинаково понимается клиентом и сервером.
    [Serializable]
    public class MarchData
    {
        public int id;
        public string ownerId;
        public string fromNodeId;
        public string targetNodeId;

        public int soldiers;   // сколько ушло
        public int survivors;  // сколько возвращается (известно после боя)
        public bool victory;
        public bool targetEmpty;    // лагерь уже разбит / ресурсная точка исчезла или занята: боя и сбора нет, все возвращаются
        public bool gather;         // поход на ресурсную точку: сбор вместо боя
        public long gatherEndMs;    // когда сбор закончится (груз полон, точка истощена или исчезла)
        public int cargo;           // сколько ресурса несёт войско (известно с начала сбора)
        public int defenders;      // гарнизон цели в момент боя
        public int defenderLosses;  // сколько потерял защитник
        public int[] units;          // состав похода по типам (TroopType); пусто -- старый поход, все считаются пехотой
        public int[] survivorUnits;  // выжившие по типам (известно после боя)

        public long battleSeed;      // номер боя: из него случайность сторон. Задаётся при выступлении и сохраняется
        public long attackerPower;   // итог боя: силы сторон x100 и выпавшая случайность (десятые доли процента)
        public long defenderPower;
        public int attackerLuck;
        public int defenderLuck;
        public int attackerConditions;      // BattleCondition нападающего в бою (голод, усталость)
        public int attackerConditionPercent; // сколько силы оставили состояния: 100 -- без штрафов
        public List<RewardEntry> loot = new List<RewardEntry>();

        public long departMs;
        public long arriveMs;
        public long returnMs;  // известно после боя
        public MarchState state;
    }

    // Скорости маршей (регламент 31.10, раздел 7, ТЕСТ). Физический марш идёт в РЕАЛЬНОМ времени (регламент, раздел 2):
    // скорость -- единиц карты за 1 реальный час, единица карты = 1 клетка = 1000 милли-единиц координат.
    // Время мира -- миллисекунды часов GameClock (реальное время + перемотка DEV).
    public sealed class MarchSpeedRules
    {
        // Милли-единиц карты за реальный час по типам войск (TroopType): пехота 8, лучники 9, кавалерия 12, осадные 4
        public int[] SpeedMilliPerHour = { 8000, 9000, 12000, 4000 };

        // Смешанное войско: true -- идёт со скоростью самого медленного типа; false -- средняя скорость,
        // взвешенная по числу воинов. Регламент правило для одной армии не задаёт -- открытый вопрос команде.
        public bool MixedUsesSlowest = true;

        public static MarchSpeedRules Default => new MarchSpeedRules();

        // Скорость войска данного состава. Состав неизвестен (старый поход) -- как у пехоты.
        public long SpeedFor(int[] units)
        {
            long slowest = long.MaxValue, weighted = 0, count = 0;
            for (int i = 0; units != null && i < units.Length && i < SpeedMilliPerHour.Length; i++)
            {
                if (units[i] <= 0) continue;
                long s = Math.Max(1, SpeedMilliPerHour[i]);
                slowest = Math.Min(slowest, s);
                weighted += s * units[i];
                count += units[i];
            }
            if (count == 0) return Math.Max(1, SpeedMilliPerHour[TroopType.Infantry]);
            return MixedUsesSlowest ? slowest : Math.Max(1, weighted / count);
        }

        // Время в пути в реальных миллисекундах
        public long TravelTimeMs(MapNode from, MapNode to, int[] units)
        {
            return (long)WorldMapLayout.Distance(from, to) * 3_600_000 / SpeedFor(units);
        }
    }

    public static class MarchRules
    {
        // Время в пути войска без известного состава (как у пехоты) при скоростях по умолчанию.
        // Для настоящего похода -- WorldSimulation.TravelTimeMs: скорости из таблицы MarchConfig и состав войска.
        public static long GetTravelTimeMs(MapNode from, MapNode to)
        {
            return MarchSpeedRules.Default.TravelTimeMs(from, to, null);
        }
    }

    public static class CampRules
    {
        // Разбитый лагерь появляется снова через 30 РЕАЛЬНЫХ минут после боя (план от 27.10.2026: "30 реальных минут"). ТЕСТ.
        public const long RespawnMs = 30L * 60 * 1000;
    }

    // Разбитый лагерь: до какого момента его нет на карте. Хранится в сохранении мира.
    [Serializable]
    public class CampState
    {
        public string id;
        public long respawnMs;
    }

    public enum WorldEventType
    {
        BattleResolved, // войско дошло, бой прошёл
        MarchReturned,  // войско вернулось домой
        GatherStarted,  // войско дошло до ресурсной точки и начало сбор (или точка исчезла -- targetEmpty)
        GatherFinished  // сбор закончен, войско идёт домой с грузом
    }

    public struct WorldEvent
    {
        public WorldEventType Type;
        public MarchData March;
        public long TimeMs; // когда событие случилось по часам игры (а не когда его заметили)
    }

    // Состояние мира: карта + походы. Не зависит от Unity -- в мультиплеере этот же код крутится на сервере,
    // а клиент только показывает то, что он вернул.
    public sealed partial class WorldSimulation
    {
        private readonly List<MapNode> nodes;
        private readonly IBattleSystem battleSystem;
        private readonly List<MarchData> marches = new List<MarchData>();
        private readonly Dictionary<string, long> campRespawn = new Dictionary<string, long>(); // id лагеря -> когда появится
        private int nextMarchId = 1;

        public IReadOnlyList<MapNode> Nodes => nodes;
        public IReadOnlyList<MarchData> Marches => marches;

        private readonly MarchSpeedRules speeds;
        public MarchSpeedRules Speeds => speeds;

        // Бой считает модуль Боевой системы -- Мир получает его через контракт, а не знает формулу сам.
        // Скорости маршей -- из таблицы (в игре MarchConfig), без неё -- значения регламента по умолчанию.
        public WorldSimulation(List<MapNode> nodes, IBattleSystem battleSystem, MarchSpeedRules speeds = null,
            ResourcePointRules pointRules = null, int seed = WorldMapLayout.DefaultSeed)
        {
            this.nodes = nodes;
            this.battleSystem = battleSystem;
            this.speeds = speeds ?? MarchSpeedRules.Default;
            this.pointRules = pointRules ?? ResourcePointRules.Default;
            this.pointSeed = seed;
        }

        // Время в пути войска данного состава (реальные миллисекунды)
        public long TravelTimeMs(MapNode from, MapNode to, int[] units)
        {
            return speeds.TravelTimeMs(from, to, units);
        }

        // Состав похода стал известен (Армия забрала воинов): время прихода пересчитывается по скорости состава.
        // Только пока войско в пути и ещё не дошло -- после боя время уже не меняется.
        public bool AssignUnits(MarchData m, int[] units)
        {
            if (m == null || m.state != MarchState.Outbound || !marches.Contains(m)) return false;
            m.units = units;
            m.arriveMs = m.departMs + TravelTimeMs(GetNode(m.fromNodeId), GetNode(m.targetNodeId), units);
            return true;
        }

        // Состояние войска нападающего на момент боя (голод в его поселении, усталость).
        // Мир сам голод не считает: его задаёт тот, кто знает поселение (MarchManager -- через модуль Населения,
        // сервер -- по своим данным). Не задано -- без штрафов.
        public Func<MarchData, BattleCondition> AttackerConditions { get; set; }

        public MapNode GetNode(string id)
        {
            return WorldMapLayout.Find(nodes, id);
        }

        // Восстановление походов из сохранения (или из ответа сервера)
        public void LoadMarches(List<MarchData> saved)
        {
            marches.Clear();
            if (saved == null) return;

            foreach (var m in saved)
            {
                // Поход к точке, которой больше нет на карте (карта поменялась), восстановить нельзя
                if (GetNode(m.fromNodeId) == null || GetNode(m.targetNodeId) == null) continue;

                marches.Add(m);
                if (m.id >= nextMarchId) nextMarchId = m.id + 1;
            }
        }

        // ---------------- Лагеря ----------------

        public bool IsCampCleared(string campId, long nowMs)
        {
            return campRespawn.TryGetValue(campId, out long at) && nowMs < at;
        }

        // Сколько миллисекунд до появления лагеря (0 -- лагерь на месте)
        public long CampRespawnInMs(string campId, long nowMs)
        {
            return campRespawn.TryGetValue(campId, out long at) && nowMs < at ? at - nowMs : 0;
        }

        public List<CampState> GetCampStates()
        {
            var list = new List<CampState>();
            foreach (var c in campRespawn) list.Add(new CampState { id = c.Key, respawnMs = c.Value });
            return list;
        }

        public void LoadCampStates(List<CampState> saved)
        {
            campRespawn.Clear();
            if (saved == null) return;
            foreach (var c in saved)
                if (c != null && GetNode(c.id) != null) campRespawn[c.id] = c.respawnMs;
        }

        // ---------------- Походы ----------------

        public MarchData StartMarch(string ownerId, string fromId, string targetId, int soldiers, long nowMs, out string error)
        {
            MapNode from = GetNode(fromId);
            MapNode target = GetNode(targetId);

            if (from == null || target == null) { error = "Неизвестная точка на карте"; return null; }
            if (target == from || !target.canBeAttacked) { error = $"На {target.displayName} нападать нельзя"; return null; }
            if (target.type == MapNodeType.Camp && IsCampCleared(targetId, nowMs))
            {
                error = $"{target.displayName} уже разбит. Появится снова через {(CampRespawnInMs(targetId, nowMs) + 59_999) / 60_000} мин";
                return null;
            }
            if (soldiers <= 0) { error = "Нужно отправить хотя бы одного солдата"; return null; }
            if (target.type == MapNodeType.ResourcePoint && !CanGatherAt(targetId, nowMs, out error)) return null;

            var march = new MarchData
            {
                id = nextMarchId++,
                ownerId = ownerId,
                fromNodeId = fromId,
                targetNodeId = targetId,
                soldiers = soldiers,
                survivors = soldiers,
                departMs = nowMs,
                arriveMs = nowMs + TravelTimeMs(from, target, null), // состав уточнит AssignUnits
                state = MarchState.Outbound,
                gather = target.type == MapNodeType.ResourcePoint
            };
            // Номер боя -- из данных похода: тот же поход всегда даёт тот же бой.
            // В мультиплеере его выдаёт сервер, иначе клиент мог бы подбирать удачный.
            march.battleSeed = BattleSeed(march.id, nowMs, targetId);
            marches.Add(march);

            error = null;
            return march;
        }

        // Откат только что созданного похода: войска для него не удалось зарезервировать.
        // Отменить можно только поход, который ещё не дошёл до цели (боя не было).
        public bool CancelMarch(int marchId)
        {
            MarchData m = marches.Find(x => x.id == marchId);
            if (m == null || m.state != MarchState.Outbound) return false;
            marches.Remove(m);
            return true;
        }

        // Продвинуть мир до момента nowMs. Если игра была закрыта долго, за один вызов поход
        // может и дойти, и вернуться -- события придут в правильном порядке.
        public void Advance(long nowMs, List<WorldEvent> events)
        {
            EnsureResourcePoints(nowMs); // первая игра: ресурсные точки появляются на карте

            // События -- строго по времени (документ 02: офлайн в причинно-следственном порядке).
            // Каждый раз берётся самое раннее: приход к цели (бой или начало сбора), конец сбора,
            // исчезновение ресурсной точки или возвращение домой. Событие назначает следующее время похода,
            // поэтому за один вызов поход может дойти, собрать и вернуться. Кто первым дошёл до лагеря или точки --
            // того и цель. При равном времени: приход, конец сбора, исчезновение точки, возвращение; затем по номеру.
            while (true)
            {
                MarchData next = null;
                ResourcePoint expiring = null;
                long nextMs = 0;
                int nextKind = int.MaxValue;
                int nextId = int.MaxValue;
                foreach (var m in marches)
                {
                    int kind;
                    long at;
                    if (m.state == MarchState.Outbound) { kind = 0; at = m.arriveMs; }
                    else if (m.state == MarchState.Gathering) { kind = 1; at = m.gatherEndMs; }
                    else if (m.state == MarchState.Returning) { kind = 3; at = m.returnMs; }
                    else continue;
                    if (at > nowMs) continue;
                    if (next == null && expiring == null || at < nextMs || at == nextMs && (kind < nextKind || kind == nextKind && m.id < nextId))
                    {
                        next = m; expiring = null; nextMs = at; nextKind = kind; nextId = m.id;
                    }
                }
                foreach (var p in points)
                {
                    // Точка без войска исчезает в срок (с войском -- её срок уже учтён в конце сбора)
                    if (!p.active || p.occupiedBy != 0 || p.expireMs > nowMs) continue;
                    if (next == null && expiring == null || p.expireMs < nextMs || p.expireMs == nextMs && 2 < nextKind)
                    {
                        next = null; expiring = p; nextMs = p.expireMs; nextKind = 2; nextId = int.MaxValue;
                    }
                }
                if (next == null && expiring == null) break;

                if (expiring != null)
                {
                    RetirePoint(expiring, nextMs);
                }
                else if (nextKind == 0 && next.gather)
                {
                    StartGather(next);
                    events.Add(new WorldEvent { Type = WorldEventType.GatherStarted, March = next, TimeMs = nextMs });
                }
                else if (nextKind == 0)
                {
                    ResolveBattle(next);
                    events.Add(new WorldEvent { Type = WorldEventType.BattleResolved, March = next, TimeMs = nextMs });
                }
                else if (nextKind == 1)
                {
                    FinishGather(next);
                    events.Add(new WorldEvent { Type = WorldEventType.GatherFinished, March = next, TimeMs = nextMs });
                }
                else
                {
                    next.state = MarchState.Finished;
                    events.Add(new WorldEvent { Type = WorldEventType.MarchReturned, March = next, TimeMs = nextMs });
                }
            }

            marches.RemoveAll(m => m.state == MarchState.Finished);
            PurgeRetiredPoints();

            // Лагеря, которые уже появились снова, больше не нужно помнить
            expiredCamps.Clear();
            foreach (var c in campRespawn) if (nowMs >= c.Value) expiredCamps.Add(c.Key);
            foreach (var id in expiredCamps) campRespawn.Remove(id);
        }

        private readonly List<string> expiredCamps = new List<string>();

        void ResolveBattle(MarchData m)
        {
            MapNode from = GetNode(m.fromNodeId);
            MapNode target = GetNode(m.targetNodeId);

            // Обратный путь отсчитывается от момента боя, а не от "сейчас" -- важно для офлайна
            m.returnMs = m.arriveMs + TravelTimeMs(target, from, HasUnits(m) ? m.units : null);
            m.state = MarchState.Returning;
            m.loot = new List<RewardEntry>();

            // Лагерь уже разбит (другим войском): боя нет, все идут домой
            if (target.type == MapNodeType.Camp && IsCampCleared(target.id, m.arriveMs))
            {
                m.targetEmpty = true;
                m.victory = false;
                m.survivors = m.soldiers;
                m.survivorUnits = HasUnits(m) ? (int[])m.units.Clone() : null;
                m.defenders = 0;
                m.defenderLosses = 0;
                return;
            }

            BattleCondition conditions = AttackerConditions != null ? AttackerConditions(m) : BattleCondition.None;
            BattleOutcome outcome = battleSystem.Resolve(new BattleRequest
            {
                AttackerUnits = HasUnits(m) ? m.units : null,
                Attackers = m.soldiers,
                DefenderUnits = WorldMapLayout.GarrisonUnits(target),
                Defenders = target.garrison,
                DefenderFortified = WorldMapLayout.IsFortified(target), // замок и города -- за стенами, лагерь -- в поле
                Seed = m.battleSeed != 0 ? m.battleSeed : BattleSeed(m.id, m.departMs, m.targetNodeId), // старые походы без номера
                AttackerConditions = conditions
            });
            m.attackerConditions = (int)conditions;
            m.attackerConditionPercent = outcome.AttackerConditionPercent;
            m.attackerPower = outcome.AttackerPower;
            m.defenderPower = outcome.DefenderPower;
            m.attackerLuck = outcome.AttackerLuckPermille;
            m.defenderLuck = outcome.DefenderLuckPermille;
            m.victory = outcome.Victory;
            m.survivors = outcome.Survivors;
            m.survivorUnits = HasUnits(m) ? outcome.AttackerSurvivorUnits : null;
            if (m.survivors > 0) // обратно идут выжившие -- со скоростью своего состава
                m.returnMs = m.arriveMs + TravelTimeMs(target, from, m.survivorUnits ?? (HasUnits(m) ? m.units : null));
            m.defenders = target.garrison;
            m.defenderLosses = outcome.DefenderLosses;
            // Гарнизон соседа пока не меняется: соседи -- заглушки. Когда они станут реальными игроками,
            // их потери будет списывать сервер из армии того игрока.
            if (outcome.Victory)
            {
                foreach (var r in target.rewards)
                    m.loot.Add(new RewardEntry { resource = r.resource, amount = r.amount });

                // Разбитый лагерь пропадает с карты и появляется снова -- отсчёт от момента боя
                if (target.type == MapNodeType.Camp) campRespawn[target.id] = m.arriveMs + CampRules.RespawnMs;
            }
        }

        // Номер боя из данных похода (FNV-1a) -- одинаков на любой платформе
        public static long BattleSeed(int marchId, long departMs, string targetId)
        {
            ulong h = 14695981039346656037UL;
            void Mix(ulong v) { for (int i = 0; i < 8; i++) { h = (h ^ (v & 0xFF)) * 1099511628211UL; v >>= 8; } }
            Mix((ulong)marchId);
            Mix((ulong)departMs);
            foreach (char c in targetId ?? "") Mix(c);
            return (long)h;
        }

        // Состав похода известен и сходится с числом воинов (у старых походов его нет)
        static bool HasUnits(MarchData m)
        {
            if (m.units == null || m.units.Length != TroopType.Count) return false;
            int n = 0;
            foreach (var u in m.units) n += u;
            return n == m.soldiers && n > 0;
        }

        // Где сейчас войско (для отрисовки). Возвращает долю пути 0..1 и точки начала/конца отрезка.
        public void GetMarchSegment(MarchData m, long nowMs, out MapNode segmentFrom, out MapNode segmentTo, out double progress)
        {
            MapNode home = GetNode(m.fromNodeId);
            MapNode target = GetNode(m.targetNodeId);

            long start, end;
            if (m.state == MarchState.Outbound)
            {
                segmentFrom = home;
                segmentTo = target;
                start = m.departMs;
                end = m.arriveMs;
            }
            else if (m.state == MarchState.Gathering)
            {
                // Войско стоит на точке и собирает
                segmentFrom = target;
                segmentTo = home;
                progress = 0;
                return;
            }
            else
            {
                segmentFrom = target;
                segmentTo = home;
                start = m.gather ? m.gatherEndMs : m.arriveMs; // после сбора -- обратно от конца сбора
                end = m.returnMs;
            }

            progress = end > start ? Math.Min(1.0, Math.Max(0.0, (nowMs - start) / (double)(end - start))) : 1.0;
        }
    }
}