using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using CommonDomain.BaseModel;
using CommonDomain.Enum;
using Microsoft.Extensions.Logging;

namespace CommonDomain
{
    public static class FishSpawnExtractor
    {
        public static string ExtractToJson(GameConfig gameConfig, ILogger logger = null)
        {
            var model = Extract(gameConfig, logger);
            if (model == null || model.Levels.Count == 0)
            {
                
                return "{}";
            }

            var json = JsonSerializer.Serialize(model, new JsonSerializerOptions
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                WriteIndented = false
            });

            
            return json;
        }

        public static FishSpawnConfigStoreModel Extract(GameConfig gameConfig, ILogger logger = null)
        {
            var result = new FishSpawnConfigStoreModel();

            if (gameConfig?.RoomConfigs == null || gameConfig.RoomConfigs.Count == 0)
            {
                
                return result;
            }

            var fishTypeDict = gameConfig.FishTypeConfigs?
                .Where(f => f != null && !string.IsNullOrWhiteSpace(f.FishNumber))
                .ToDictionary(f => f.FishNumber, f => f)
                ?? new Dictionary<string, FishTypeConfig>();

            var fishArrayDict = gameConfig.FishArrayConfigs?
                .Where(a => a != null && !string.IsNullOrWhiteSpace(a.FishArrayNumber))
                .ToDictionary(a => a.FishArrayNumber, a => a)
                ?? new Dictionary<string, FishArrayConfig>();

            foreach (var roomCfg in gameConfig.RoomConfigs)
            {
                if (roomCfg == null) continue;

                var roomFishCfg = gameConfig.RoomFishConfigs?
                    .FirstOrDefault(r => r.GameType == roomCfg.GameType);

                if (roomFishCfg == null)
                {
                    
                    continue;
                }

                int roomLevel = roomCfg.RoomLevel;

                var levelKey = $"{(int)roomCfg.GameType}:{roomLevel}";
                if (result.Levels.ContainsKey(levelKey)) continue;

                var levelConfig = new FishSpawnLevelConfig
                {
                    GameType = (int)roomCfg.GameType,
                    RoomLevel = roomLevel
                };

                if (roomFishCfg.RoomFishProbabilityList != null)
                {
                    foreach (var prob in roomFishCfg.RoomFishProbabilityList)
                    {
                        if (prob == null || prob.RoomLevel != roomLevel) continue;

                        levelConfig.Probabilities.Add(new FishSpawnProbability
                        {
                            Type = prob.Type,
                            FishType = (int)prob.FishType,
                            FirstFishCountMin = prob.FirstFishCountRange != null && prob.FirstFishCountRange.Count > 0 ? prob.FirstFishCountRange[0] : 0,
                            FirstFishCountMax = prob.FirstFishCountRange != null && prob.FirstFishCountRange.Count > 1 ? prob.FirstFishCountRange[1] : 0,
                            TimeMin = prob.TimeRange != null && prob.TimeRange.Count > 0 ? prob.TimeRange[0] : 3,
                            TimeMax = prob.TimeRange != null && prob.TimeRange.Count > 1 ? prob.TimeRange[1] : 8,
                            CountMin = prob.CountRange != null && prob.CountRange.Count > 0 ? prob.CountRange[0] : 1,
                            CountMax = prob.CountRange != null && prob.CountRange.Count > 1 ? prob.CountRange[1] : 3,
                            MaxCountMin = prob.MaxCountRange != null && prob.MaxCountRange.Count > 0 ? prob.MaxCountRange[0] : 5,
                            MaxCountMax = prob.MaxCountRange != null && prob.MaxCountRange.Count > 1 ? prob.MaxCountRange[1] : 20
                        });
                    }
                }

                var processedFishNumbers = new HashSet<string>();

                if (roomFishCfg.RoomFishLevelList != null)
                {
                    foreach (var fish in roomFishCfg.RoomFishLevelList)
                    {
                        if (fish == null || fish.RoomLevel != roomLevel) continue;
                        if (fish.Type != 1) continue;
                        if (string.IsNullOrWhiteSpace(fish.FishNumber)) continue;

                        processedFishNumbers.Add(fish.FishNumber);
                        fishTypeDict.TryGetValue(fish.FishNumber, out var ft);

                        levelConfig.Fishes.Add(new FishSpawnFish
                        {
                            FishNumber = fish.FishNumber,
                            FishWeight = fish.FishWeight,
                            Times = fish.Times,
                            MaxCount = fish.MaxCount,
                            FishType = ft != null ? (int)ft.FishType : 0,
                            PathList = ft?.PathList ?? new List<int>()
                        });
                    }
                }

                if (roomFishCfg.NormalFishList != null)
                {
                    foreach (var fish in roomFishCfg.NormalFishList)
                    {
                        if (fish == null || fish.Type != 1) continue;
                        if (string.IsNullOrWhiteSpace(fish.FishNumber)) continue;
                        if (processedFishNumbers.Contains(fish.FishNumber)) continue;

                        processedFishNumbers.Add(fish.FishNumber);
                        fishTypeDict.TryGetValue(fish.FishNumber, out var ft);

                        levelConfig.Fishes.Add(new FishSpawnFish
                        {
                            FishNumber = fish.FishNumber,
                            FishWeight = fish.FishWeight > 0 ? fish.FishWeight : 1,
                            Times = fish.Times > 0 ? fish.Times : 8,
                            MaxCount = fish.MaxCount > 0 ? fish.MaxCount : 20,
                            FishType = ft != null ? (int)ft.FishType : 0,
                            PathList = ft?.PathList ?? new List<int>()
                        });
                    }
                }

                var processedArrayNumbers = new HashSet<string>();

                if (roomFishCfg.RoomFishLevelList != null)
                {
                    foreach (var fish in roomFishCfg.RoomFishLevelList)
                    {
                        if (fish == null || fish.RoomLevel != roomLevel) continue;
                        if (fish.Type != 2) continue;
                        if (string.IsNullOrWhiteSpace(fish.FishNumber)) continue;

                        if (!fishArrayDict.TryGetValue(fish.FishNumber, out var arrayCfg)) continue;
                        if (processedArrayNumbers.Contains(fish.FishNumber)) continue;
                        processedArrayNumbers.Add(fish.FishNumber);

                        levelConfig.FishArrays.Add(new FishSpawnArray
                        {
                            FishArrayNumber = fish.FishNumber,
                            ArrayNumber = arrayCfg.ArrayNumber ?? string.Empty,
                            FishNumber = arrayCfg.FishNumber ?? string.Empty,
                            BossFishNumber = arrayCfg.BossFishNumber ?? string.Empty,
                            FishCount = arrayCfg.FishCount,
                            BossCount = arrayCfg.BoosCount,
                            GenerateFrequency = arrayCfg.GenerateFrequency
                        });
                    }
                }

                if (levelConfig.Probabilities.Count > 0 || levelConfig.Fishes.Count > 0)
                {
                    result.Levels[levelKey] = levelConfig;
                    
                }
            }

            return result;
        }
    }
}