global using Supercell.Laser.Logic.Data.Helper;
global using Supercell.Laser.Logic.Data.Reader;

namespace Supercell.Laser.Logic.Data
{
    using Supercell.Laser.Logic.Data.Helper;
    using Supercell.Laser.Logic.Data.Reader;
    using Supercell.Laser.Titan.Debug;
    
    public partial class DataTables
    {
        public static readonly Dictionary<DataType, string> Gamefiles = new Dictionary<DataType, string>();
        private static Gamefiles Tables;

        private static void AddFilesToLoad()
        {
            Gamefiles.Add(DataType.Projectile, "Assets/csv_logic/projectiles.csv");
            Gamefiles.Add(DataType.AllianceBadge, "Assets/csv_logic/alliance_badges.csv");
            Gamefiles.Add(DataType.Location, "Assets/csv_logic/locations.csv");
            Gamefiles.Add(DataType.Character, "Assets/csv_logic/characters.csv");
            Gamefiles.Add(DataType.AreaEffect, "Assets/csv_logic/area_effects.csv");
            Gamefiles.Add(DataType.Item, "Assets/csv_logic/items.csv");
            Gamefiles.Add(DataType.Skill, "Assets/csv_logic/skills.csv");
            Gamefiles.Add(DataType.Card, "Assets/csv_logic/cards.csv");
            Gamefiles.Add(DataType.Tile, "Assets/csv_logic/tiles.csv");
            Gamefiles.Add(DataType.PlayerThumbnail, "Assets/csv_logic/player_thumbnails.csv");
            Gamefiles.Add(DataType.Skin, "Assets/csv_logic/skins.csv");
            Gamefiles.Add(DataType.Milestone, "Assets/csv_logic/milestones.csv");
            Gamefiles.Add(DataType.SkinConf, "Assets/csv_logic/skin_confs.csv");
            Gamefiles.Add(DataType.Emote, "Assets/csv_logic/emotes.csv");
        }

        public static void Load()
        {
            DataTables.AddFilesToLoad();

            Tables = new Gamefiles();

            foreach (var file in Gamefiles)
                Tables.Initialize(new Table(file.Value), file.Key);

            ResolveParentProjectileData();
            ResolveParentAreaEffectData();

            Debugger.Print($"{Gamefiles.Count} Data Tables initialized!");
        }

        public static bool TableExists(int t)
        {
            return Tables.ContainsTable(t);
        }

        public static DataTable Get(DataType classId)
        {
            return Tables.Get(classId);
        }

        public static DataTable Get(int classId)
        {
            return Tables.Get(classId);
        }

        public static CharacterData GetCharacterByName(string name)
        {
            return Get(16).GetData<CharacterData>(name);
        }
        public static ProjectileData GetProjectileByName(string name)
        {
            return Get(6).GetData<ProjectileData>(name);
        }
        public static AreaEffectData GetAreaEffectByName(string name)
        {
            return Get(DataType.AreaEffect).GetData<AreaEffectData>(name);
        }

        private static void ResolveParentProjectileData()
        {
            DataTable projectileTable = Get(DataType.Projectile);
            foreach (ProjectileData projectile in projectileTable.GetDatas())
            {
                ResolveParentProjectileData(projectile, new HashSet<string>());
            }
        }

        private static void ResolveParentProjectileData(ProjectileData projectile, HashSet<string> visited)
        {
            if (projectile == null || string.IsNullOrEmpty(projectile.ParentProjectileForSkin))
            {
                return;
            }

            if (!visited.Add(projectile.Name))
            {
                return;
            }

            ProjectileData parent = Get(DataType.Projectile).GetData<ProjectileData>(projectile.ParentProjectileForSkin);
            if (parent == null)
            {
                return;
            }

            ResolveParentProjectileData(parent, visited);
            projectile.ApplyParentData(parent, nameof(ProjectileData.Name), nameof(ProjectileData.ParentProjectileForSkin));
        }

        private static void ResolveParentAreaEffectData()
        {
            DataTable areaEffectTable = Get(DataType.AreaEffect);
            foreach (AreaEffectData areaEffect in areaEffectTable.GetDatas())
            {
                ResolveParentAreaEffectData(areaEffect, new HashSet<string>());
            }
        }

        private static void ResolveParentAreaEffectData(AreaEffectData areaEffect, HashSet<string> visited)
        {
            if (areaEffect == null || string.IsNullOrEmpty(areaEffect.ParentAreaEffectForSkin))
            {
                return;
            }

            if (!visited.Add(areaEffect.Name))
            {
                return;
            }

            AreaEffectData parent = Get(DataType.AreaEffect).GetData<AreaEffectData>(areaEffect.ParentAreaEffectForSkin);
            if (parent == null)
            {
                return;
            }

            ResolveParentAreaEffectData(parent, visited);
            areaEffect.ApplyParentData(parent, nameof(AreaEffectData.Name), nameof(AreaEffectData.ParentAreaEffectForSkin));
        }

        public static ItemData GetItemByName(string name)
        {
            return Get(DataType.Item).GetData<ItemData>(name);
        }
        public static CardData GetUnlockCardFor(CharacterData character)
        {
            foreach(CardData i in Get(DataType.Card).GetDatas())
            {
                if (i.Target == character.Name && i.Type == "unlock") return i;
            }
            return null;
        }
    }
}