using System;
using System.Collections.Generic;
using System.Globalization;
using UnityEngine;

namespace TKS.OutGame
{
    /// <summary>연무장 전투 1판의 결과(결과 패널 · 화면 표시).</summary>
    public class ModeResult
    {
        public string kind;
        public string title;
        public bool win;
        public List<string> lines = new List<string>();
    }

    /// <summary>
    /// 연무장 규칙(기획서 §9 · S13 · PD #1093 C) — ① 천하제일 탑(tower.csv · 입장권 tower_tickets_daily/일 + 광고 tower_ad_tickets · 입장 = 1장 · 승리 = 다음 층 · 보옥·도면·상자)
    /// ② 일일 던전(dungeons.csv · 요일 · entries_per_day/일 · 템플릿 × hp_mult · 보상 = reward_amount) ③ 투기장(arena.csv · 샘플 상대 sample_lineups(heroes.csv 에서 생성 · 세이브) ·
    /// 방어 = 기존 EnemyAI · entries_per_day/일 · 메달 승/패 · 주간 순위(로컬) · 메달 → 영웅 조각 상점) ④ 적장 토벌(raid_bosses 주간 순환 · 보스 hp × raid_hp_mult · raid_turns 턴 · 누적 피해 · raid_daily/일 · 명장 상자 + 천기 raid_arcana_pct).
    /// 적 편성 = 챕터 스테이지 템플릿(BalanceConfig.stages)을 복사해 배율만 곱한다.
    /// </summary>
    public static class ArenaRules
    {
        public const string Tower = "tower";
        public const string Dungeon = "dungeon";
        public const string Arena = "arena";
        public const string Raid = "raid";

        // ---------- 공통 ----------

        public static bool ParseStageKey(string key, out int chapter, out int stage)
        {
            chapter = stage = 0;
            if (string.IsNullOrEmpty(key)) return false;
            var p = key.Split('-');
            return p.Length == 2 && int.TryParse(p[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out chapter) && int.TryParse(p[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out stage);
        }

        public static BalanceConfig.StageDef FindStage(BalanceConfig cfg, string key)
        {
            int ch, st;
            if (!ParseStageKey(key, out ch, out st)) return null;
            foreach (var s in cfg.stages)
                if (s.chapter == ch && s.stage == st) return s;
            return null;
        }

        /// <summary>템플릿 스테이지 복사(적 hp/atk 배율 곱 · 제목 교체).</summary>
        public static BalanceConfig.StageDef CopyStage(BalanceConfig.StageDef src, string title, float hpMult, float atkMult)
        {
            var s = new BalanceConfig.StageDef
            {
                title = title, subtitle = src.title, aiAccuracy = src.aiAccuracy, aiAggroRange = src.aiAggroRange,
                chapter = src.chapter, stage = src.stage, kind = src.kind, place = src.place, faction = src.faction, bgTheme = src.bgTheme, note = src.note,
            };
            foreach (var e in src.enemies)
                s.enemies.Add(new BalanceConfig.EnemySpawn
                {
                    name = e.name, type = e.type, position = e.position, hpMult = e.hpMult * hpMult, atkMult = e.atkMult * atkMult, isBoss = e.isBoss, isGeneral = e.isGeneral, art = e.art,
                });
            return s;
        }

        /// <summary>날짜가 바뀌면 일일 횟수 초기화 · 탑 입장권을 하루치까지 채움.</summary>
        public static void RollDaily(OutGameData db, SaveData d, DateTime nowUtc)
        {
            var day = EconomyRules.DayKey(nowUtc);
            if (d.dailyC != null && d.dailyC.day == day) return;
            d.dailyC = new DailyC { day = day };
            d.arena.towerTickets = Mathf.Max(d.arena.towerTickets, db.Economy.TowerTicketsDaily);
        }

        /// <summary>전투 결과 공통: 전투 카운터 · 쓰러진 적 보스 수(보물 조건 효과).</summary>
        public static void CountBattle(SaveData d, BattleManager bm)
        {
            TreasureRules.AddCount(d, BattleEvents.Battles, 1);
            int bosses = 0;
            foreach (var u in bm.Units)
                if (u != null && u.Faction == Faction.Enemy && u.IsBoss && !u.IsAlive) bosses++;
            TreasureRules.AddCount(d, BattleEvents.BossKills, bosses);
        }

        // ---------- 천하제일 탑 ----------

        public static int TowerNext(OutGameData db, SaveData d)
        {
            return Mathf.Min(d.arena.towerFloor + 1, db.Tower.Top);
        }

        public static string CanTower(OutGameData db, SaveData d, DateTime nowUtc)
        {
            RollDaily(db, d, nowUtc);
            if (d.arena.towerFloor >= db.Tower.Top) return "100층 정복 완료";
            if (d.arena.towerTickets <= 0) return "입장권 없음(매일 " + db.Economy.TowerTicketsDaily + "장 · 광고 +" + db.Economy.TowerAdTickets + ")";
            return null;
        }

        public static BalanceConfig.StageDef TowerStage(OutGameData db, BalanceConfig cfg, int floor)
        {
            var f = db.Tower.Get(floor);
            var src = f != null ? FindStage(cfg, f.templateStage) : null;
            return src == null ? null : CopyStage(src, "천하제일 탑 " + floor + "층", f.hpMult, f.atkMult);
        }

        /// <summary>입장 = 입장권 1장(승패 무관).</summary>
        public static string EnterTower(OutGameData db, SaveData d, DateTime nowUtc)
        {
            var why = CanTower(db, d, nowUtc);
            if (why != null) return why;
            d.arena.towerTickets--;
            return null;
        }

        public static string TowerAd(OutGameData db, SaveData d, DateTime nowUtc)
        {
            RollDaily(db, d, nowUtc);
            if (d.dailyC.towerAd >= 1) return "오늘 광고 입장권을 받았습니다";
            d.dailyC.towerAd++;
            d.arena.towerTickets += db.Economy.TowerAdTickets;
            return null;
        }

        public static ModeResult TowerResult(OutGameData db, SaveData d, int floor, bool win, System.Random rng)
        {
            var r = new ModeResult { kind = Tower, win = win, title = "천하제일 탑 " + floor + "층" };
            if (!win)
            {
                r.lines.Add("도전 실패 — 입장권 1장 소모 · 층 유지");
                return r;
            }
            var f = db.Tower.Get(floor);
            d.arena.towerFloor = Mathf.Max(d.arena.towerFloor, floor);
            int gem = Mathf.RoundToInt(f.rewardGem * DevRules.Mult(db, d, DevRules.GemBonus));
            int bp = Mathf.RoundToInt(f.rewardBlueprint * DevRules.Mult(db, d, DevRules.BlueprintGain));
            d.gem += gem;
            d.inv.blueprint += bp;
            r.lines.Add("보옥 +" + gem + " · 도면 +" + bp);
            if (f.chest.Length > 0)
            {
                var got = TreasureRules.AddChest(db, d, f.chest, rng);
                if (got != null) r.lines.Add(db.Chests.Get(got).nameKo + " 획득");
            }
            r.lines.Add("다음 = " + TowerNext(db, d) + "층");
            return r;
        }

        // ---------- 일일 던전 ----------

        public static bool OpenToday(DungeonDb.Dungeon dg, DateTime nowUtc)
        {
            return dg.OpenOn(nowUtc.ToLocalTime().DayOfWeek);
        }

        public static int DungeonLeft(OutGameData db, SaveData d, DungeonDb.Dungeon dg, DateTime nowUtc)
        {
            RollDaily(db, d, nowUtc);
            return Mathf.Max(0, dg.entriesPerDay - d.dailyC.Dungeon(dg.id));
        }

        public static string CanDungeon(OutGameData db, SaveData d, string id, DateTime nowUtc)
        {
            var dg = db.Dungeons.Get(id);
            if (dg == null) return "없는 던전";
            if (!OpenToday(dg, nowUtc)) return "오늘은 닫힘";
            if (DungeonLeft(db, d, dg, nowUtc) <= 0) return "오늘 입장 " + dg.entriesPerDay + "회 완료";
            return null;
        }

        public static BalanceConfig.StageDef DungeonStage(OutGameData db, BalanceConfig cfg, string id)
        {
            var dg = db.Dungeons.Get(id);
            var src = dg != null ? FindStage(cfg, dg.templateStage) : null;
            return src == null ? null : CopyStage(src, dg.nameKo + " 던전", dg.hpMult, 1f);
        }

        /// <summary>입장 횟수는 승리했을 때만 소모(패배 = 다시 도전 가능 · PD 확인 대상).</summary>
        public static ModeResult DungeonResult(OutGameData db, SaveData d, string id, bool win, DateTime nowUtc, System.Random rng)
        {
            var dg = db.Dungeons.Get(id);
            var r = new ModeResult { kind = Dungeon, win = win, title = dg.nameKo + " 던전" };
            if (!win)
            {
                r.lines.Add("도전 실패 — 입장 횟수 유지");
                return r;
            }
            RollDaily(db, d, nowUtc);
            d.dailyC.AddDungeon(id);
            foreach (var k in dg.rewardKinds)
            {
                int n = dg.Amount(k);
                switch (k)
                {
                    case "gold":
                        n = Mathf.RoundToInt(n * DevRules.Mult(db, d, DevRules.GoldGain));
                        d.gold += n;
                        r.lines.Add("골드 +" + n.ToString("N0"));
                        break;
                    case "iron":
                        n = Mathf.RoundToInt(n * DevRules.Mult(db, d, DevRules.IronGain));
                        d.inv.iron += n;
                        r.lines.Add("운철 +" + n);
                        break;
                    case "skill_book":
                        d.inv.books.skill += n;
                        r.lines.Add("스킬서 +" + n);
                        break;
                    case "gear":
                        float gf = n * DevRules.Mult(db, d, DevRules.DungeonGear);
                        int cnt = Mathf.FloorToInt(gf + 1e-4f) + (rng.NextDouble() < gf - Mathf.Floor(gf + 1e-4f) ? 1 : 0);
                        var row = db.Rewards.For(Mathf.Max(1, d.chapterMax));
                        int maxOrder = row != null ? db.Gear.OrderOf(row.gearGradeMax) : 1;
                        var pool = new List<GearDb.Item>();
                        foreach (var it in db.Gear.items)
                            if (it.order <= maxOrder) pool.Add(it);
                        for (int i = 0; i < cnt && pool.Count > 0; i++)
                        {
                            var g = pool[rng.Next(pool.Count)];
                            d.inv.AddGear(g.id, 1);
                            r.lines.Add("장비 " + g.nameKo + " (" + UiKit.GradeKo(g.grade) + ")");
                        }
                        break;
                    case "shards":
                        var heroes = new List<HeroState>();
                        foreach (var h in d.heroes) heroes.Add(h);
                        if (heroes.Count == 0) break;
                        var pick = heroes[rng.Next(heroes.Count)];
                        pick.shards += n;
                        var def = db.Heroes.Get(pick.id);
                        r.lines.Add((def != null ? def.nameKo : pick.id) + " 조각 +" + n);
                        break;
                }
            }
            r.lines.Add("오늘 남은 입장 " + DungeonLeft(db, d, dg, nowUtc) + " / " + dg.entriesPerDay);
            return r;
        }

        // ---------- 투기장 ----------

        public static int ArenaLeft(OutGameData db, SaveData d, DateTime nowUtc)
        {
            RollDaily(db, d, nowUtc);
            return Mathf.Max(0, db.Arena.EntriesPerDay - d.dailyC.arena);
        }

        static int MaxOwnedLevel(SaveData d)
        {
            int m = 1;
            foreach (var h in d.heroes) m = Mathf.Max(m, h.lv);
            foreach (var u in d.units) m = Mathf.Max(m, u.lv);
            return m;
        }

        /// <summary>
        /// 시즌 유지: 시작 시각이 없으면 지금 시작 · season_days 지나면 순위 보상(1~10위 top10 · 그 밖 top100 보옥) 후 새 시즌 ·
        /// 샘플 상대가 없으면 생성(영웅 5인 무작위 · Lv = 보유 최고 Lv ± · 점수 = sample_score_step × 순번 · 임시 규칙 = PD 확인 대상).
        /// </summary>
        public static void EnsureSeason(OutGameData db, SaveData d, DateTime nowUtc, System.Random rng)
        {
            var a = d.arena;
            var start = SaveStore.ParseIso(a.seasonStart, DateTime.MinValue);
            if (start == DateTime.MinValue)
            {
                a.seasonStart = SaveStore.Iso(nowUtc);
                a.samples.Clear();
            }
            else if ((nowUtc - start).TotalDays >= Mathf.Max(1, db.Arena.SeasonDays))
            {
                int rank = Rank(d);
                int gem = rank <= 10 ? db.Arena.RewardTop10Gem : db.Arena.RewardTop100Gem;
                d.gem += gem;
                a.lastSeason = "지난 시즌 " + rank + "위 · 보옥 +" + gem;
                a.seasonStart = SaveStore.Iso(nowUtc);
                a.seasonScore = 0;
                a.samples.Clear();
            }
            if (a.samples.Count == 0) a.samples.AddRange(MakeSamples(db, d, rng));
        }

        public static List<ArenaSample> MakeSamples(OutGameData db, SaveData d, System.Random rng)
        {
            var pool = new List<HeroDb.Hero>();
            foreach (var h in db.Heroes.heroes)
                if (!h.isSoldier) pool.Add(h);
            int n = Mathf.Max(1, db.Arena.SampleLineups);
            int top = MaxOwnedLevel(d);
            var res = new List<ArenaSample>();
            for (int k = 0; k < n; k++)
            {
                var s = new ArenaSample { lv = Mathf.Clamp(top + k - n / 2, 1, db.Levels.MaxLevel), score = db.Arena.SampleScoreStep * (k + 1) };
                var bag = new List<HeroDb.Hero>(pool);
                for (int i = 0; i < 5 && bag.Count > 0; i++)
                {
                    int j = rng.Next(bag.Count);
                    s.heroes.Add(bag[j].id);
                    bag.RemoveAt(j);
                }
                var lead = db.Heroes.Get(s.heroes[0]);
                s.name = (lead != null ? lead.nameKo : "?") + " 군 · Lv " + s.lv;
                res.Add(s);
            }
            return res;
        }

        /// <summary>내 주간 순위 = 1 + 나보다 점수 높은 샘플 수.</summary>
        public static int Rank(SaveData d)
        {
            int r = 1;
            foreach (var s in d.arena.samples)
                if (s.score > d.arena.seasonScore) r++;
            return r;
        }

        public static string CanArena(OutGameData db, SaveData d, int sample, DateTime nowUtc)
        {
            if (sample < 0 || sample >= d.arena.samples.Count) return "없는 상대";
            if (ArenaLeft(db, d, nowUtc) <= 0) return "오늘 " + db.Arena.EntriesPerDay + "회 완료";
            return null;
        }

        /// <summary>상대 편성 = 샘플 영웅 5인(Lv · 초기 등급 · ★ = 희귀도 · §3-2 공식) · 자리 = 아군 출발 자리의 위아래 반전 · 무장(패시브 Lv1 · EnemyAI 방어).</summary>
        public static BalanceConfig.StageDef ArenaStage(OutGameData db, BalanceConfig cfg, ArenaSample s)
        {
            var st = new BalanceConfig.StageDef { title = "투기장 — " + s.name, subtitle = "비동기 5v5", chapter = 0, stage = 0, kind = StageKind.Normal };
            for (int i = 0; i < s.heroes.Count && i < cfg.playerSpawnPoints.Length; i++)
            {
                var h = db.Heroes.Get(s.heroes[i]);
                if (h == null) continue;
                var hs = new HeroState { id = h.id, lv = s.lv, grade = db.Promotion.FirstGrade, star = Mathf.Clamp(h.rarity, 1, db.Evolve.MaxStar) };
                var stats = HeroRules.Compute(db, cfg, h, hs);
                var p = cfg.playerSpawnPoints[i];
                st.enemies.Add(new BalanceConfig.EnemySpawn
                {
                    name = h.nameKo, type = h.type, position = new Vector2(p.x, -p.y), art = h.art, isGeneral = true,
                    hpMult = h.hpMult * stats.GrowthOf("hp"), atkMult = h.atkMult * stats.GrowthOf("atk"),
                });
            }
            return st;
        }

        public static ModeResult ArenaResult(OutGameData db, SaveData d, int sample, bool win, DateTime nowUtc)
        {
            RollDaily(db, d, nowUtc);
            d.dailyC.arena++;
            int medals = win ? db.Arena.MedalWin : db.Arena.MedalLose;
            d.arena.medals += medals;
            d.arena.seasonScore += medals;
            if (win) d.arena.wins++;
            else d.arena.losses++;
            var s = sample >= 0 && sample < d.arena.samples.Count ? d.arena.samples[sample] : null;
            var r = new ModeResult { kind = Arena, win = win, title = "투기장 " + (win ? "승리" : "패배") };
            r.lines.Add((s != null ? s.name : "상대") + " 상대");
            r.lines.Add("메달 +" + medals + " (보유 " + d.arena.medals + ")");
            r.lines.Add("주간 점수 " + d.arena.seasonScore + " · 순위 " + Rank(d) + "위");
            r.lines.Add("오늘 남은 도전 " + ArenaLeft(db, d, nowUtc) + " / " + db.Arena.EntriesPerDay);
            return r;
        }

        /// <summary>메달 상점: shop_price 메달 → 그 영웅 조각 shop_shards(하루 shop_daily 회 · 보유 영웅만).</summary>
        public static string BuyShards(OutGameData db, SaveData d, string heroId, DateTime nowUtc)
        {
            RollDaily(db, d, nowUtc);
            var hs = d.Hero(heroId);
            if (hs == null) return "보유 영웅만";
            if (d.dailyC.arenaShop >= db.Arena.ShopDaily) return "오늘 " + db.Arena.ShopDaily + "회 완료";
            if (d.arena.medals < db.Arena.ShopPrice) return "메달 부족 " + d.arena.medals + " / " + db.Arena.ShopPrice;
            d.arena.medals -= db.Arena.ShopPrice;
            d.dailyC.arenaShop++;
            hs.shards += db.Arena.ShopShards;
            return null;
        }

        // ---------- 적장 토벌 ----------

        /// <summary>주 키(현지 · 월요일 시작 · yyyy-ww).</summary>
        public static string WeekKey(DateTime nowUtc)
        {
            var local = nowUtc.ToLocalTime().Date;
            int week = CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(local, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
            return local.Year.ToString(CultureInfo.InvariantCulture) + "-" + week.ToString("00", CultureInfo.InvariantCulture);
        }

        /// <summary>이번 주 보스 = raid_bosses 를 주 번호로 순환 · 주가 바뀌면 누적 피해 초기화.</summary>
        public static string RaidBoss(OutGameData db, SaveData d, DateTime nowUtc)
        {
            var bosses = db.Economy.RaidBosses;
            if (bosses.Length == 0) return "";
            var wk = WeekKey(nowUtc);
            int week;
            int.TryParse(wk.Substring(wk.Length - 2), NumberStyles.Integer, CultureInfo.InvariantCulture, out week);
            var boss = bosses[week % bosses.Length];
            if (d.arena.raidWeek != wk || d.arena.raidBoss != boss)
            {
                d.arena.raidWeek = wk;
                d.arena.raidBoss = boss;
                d.arena.raidDamage = 0;
            }
            return boss;
        }

        public static int RaidLeft(OutGameData db, SaveData d, DateTime nowUtc)
        {
            RollDaily(db, d, nowUtc);
            return Mathf.Max(0, db.Economy.RaidDaily - d.dailyC.raid);
        }

        public static string CanRaid(OutGameData db, SaveData d, DateTime nowUtc)
        {
            if (RaidLeft(db, d, nowUtc) <= 0) return "오늘 " + db.Economy.RaidDaily + "회 완료";
            return null;
        }

        /// <summary>보스 편성 = 그 영웅 아트가 보스인 첫 스테이지(없으면 보스 1기) · 보스 hp × raid_hp_mult.</summary>
        public static BalanceConfig.StageDef RaidStage(OutGameData db, BalanceConfig cfg, string bossId)
        {
            var h = db.Heroes.Get(bossId);
            if (h == null) return null;
            string title = "적장 토벌 — " + h.nameKo;
            foreach (var s in cfg.stages)
                foreach (var e in s.enemies)
                    if (e.isBoss && e.art == h.art)
                    {
                        var c = CopyStage(s, title, 1f, 1f);
                        foreach (var ce in c.enemies)
                            if (ce.isBoss && ce.art == h.art) ce.hpMult *= db.Economy.RaidHpMult;
                        return c;
                    }
            var st = new BalanceConfig.StageDef { title = title, subtitle = "주간 보스", kind = StageKind.Boss };
            st.enemies.Add(new BalanceConfig.EnemySpawn { name = h.nameKo, type = h.type, position = new Vector2(0f, 8f), hpMult = h.hpMult * db.Economy.RaidHpMult, atkMult = h.atkMult, isBoss = true, isGeneral = true, art = h.art });
            return st;
        }

        /// <summary>토벌 1회: 보스에게 준 피해 누적 · 명장 상자(raid_chest) · 천기 확률(raid_arcana_pct · 미보유 = 획득 · 보유 = 조각).</summary>
        public static ModeResult RaidResult(OutGameData db, SaveData d, string bossId, int damage, bool killed, DateTime nowUtc, System.Random rng)
        {
            RollDaily(db, d, nowUtc);
            d.dailyC.raid++;
            RaidBoss(db, d, nowUtc);
            d.arena.raidDamage += Mathf.Max(0, damage);
            var h = db.Heroes.Get(bossId);
            var r = new ModeResult { kind = Raid, win = true, title = "적장 토벌 — " + (h != null ? h.nameKo : bossId) };
            r.lines.Add("이번 피해 " + damage.ToString("N0") + (killed ? " (격파!)" : ""));
            r.lines.Add("이번 주 누적 " + d.arena.raidDamage.ToString("N0"));
            var got = TreasureRules.AddChest(db, d, db.Economy.RaidChest, rng);
            if (got != null) r.lines.Add(db.Chests.Get(got).nameKo + " 획득");
            if (rng.NextDouble() < db.Economy.RaidArcanaPct)
            {
                bool isNew = false;
                int shards = 0;
                var top = db.Economy.TreasureGrades;
                var id = top.Count > 0 ? TreasureRules.GrantGrade(db, d, top[top.Count - 1].Key, rng, out isNew, out shards) : null;
                if (id != null) r.lines.Add("천기 보물 " + db.Treasures.Get(id).nameKo + (isNew ? " 획득!" : " 조각 +" + shards));
            }
            return r;
        }
    }
}