using System.Globalization;
using CsvHelper;
using CsvHelper.Configuration;
using DCGEngine.Database.Interfaces;
using Microsoft.EntityFrameworkCore;
using SVSim.Database.Models;

namespace SVSim.Database.DataSeeders;

/// <summary>
/// Loads base data aside from cards into the DB. Cards excluded due to how many of them there are.
/// </summary>
public class BaseDataSeeder : IDataSeeder
{
    private class ClassEntryMap : ClassMap<ClassEntry>
    {
        public ClassEntryMap()
        {
            Map(m => m.Id).Name("id");
            Map(m => m.Name).Name("name");
            Map(m => m.DefaultLeaderSkin).Ignore();
        }
    }
    private class LeaderSkinEntryMap : ClassMap<LeaderSkinEntry>
    {
        public LeaderSkinEntryMap()
        {
            Map(m => m.Id).Name("class_chara_id");
            Map(m => m.Name).Name("class_chara_name");
            Map(m => m.ClassId).Name("clan");
            Map(m => m.Class).Ignore();
            Map(m => m.Viewers).Ignore();
            Map(m => m.EmoteId).Ignore();
        }
    }
    private class EmblemEntryMap : ClassMap<EmblemEntry>
    {
        public EmblemEntryMap()
        {
            Map(m => m.Id).Name("emblem_id");
        }
    }
    private class SleeveEntryMap : ClassMap<SleeveEntry>
    {
        public SleeveEntryMap()
        {
            Map(m => m.Id).Name("sleeve_id");
        }
    }

    private class DegreeEntryMap : ClassMap<DegreeEntry>
    {
        public DegreeEntryMap()
        {
            Map(m => m.Id).Name("degree_id");
        }
    }

    private class BattlefieldEntryMap : ClassMap<BattlefieldEntry>
    {
        public BattlefieldEntryMap()
        {
            Map(m => m.Id).Name("value");
            Map(m => m.IsOpen).Name("is_open");
        }
    }

    private class MyPageBackgroundEntryMap : ClassMap<MyPageBackgroundEntry>
    {
        public MyPageBackgroundEntryMap()
        {
            Map(m => m.Id).Name("id");
        }
    }

    private class ClassExpEntryMap : ClassMap<ClassExpEntry>
    {
        public ClassExpEntryMap()
        {
            Map(m => m.Id).Name("level");
            Map(m => m.NecessaryExp).Name("necessary_exp");
        }
    }

    private class RankInfoEntryMap : ClassMap<RankInfoEntry>
    {
        public RankInfoEntryMap()
        {
            Map(m => m.Id).Name("rank_id");
            Map(m => m.Name).Name("rank_name");
            Map(m => m.NecessaryPoint).Name("necessary_point");
            Map(m => m.AccumulatePoint).Name("accumulate_point");
            Map(m => m.LowerLimitPoint).Name("lower_limit_point");
            Map(m => m.BaseAddBp).Name("base_add_bp");
            Map(m => m.BaseDropBp).Name("base_drop_bp");
            Map(m => m.StreakBonusPt).Name("streak_bonus_pt");
            Map(m => m.WinBonus).Name("win_bonus");
            Map(m => m.LoseBonus).Name("lose_bonus");
            Map(m => m.MaxWinBonus).Name("max_win_bonus");
            Map(m => m.MaxLoseBonus).Name("max_lose_bonus");
            Map(m => m.IsPromotionWar).Name("is_promotion_war");
            Map(m => m.MatchCount).Name("match_count");
            Map(m => m.NecessaryWin).Name("necessary_win");
            Map(m => m.ResetLose).Name("reset_lose");
            Map(m => m.AccumulateMasterPoint).Name("accumulate_master_point");
        }
    }

    public void Seed(ModelBuilder builder)
    {
        List<ClassEntry> classes = new();
        List<LeaderSkinEntry> leaderSkins = new();
        List<EmblemEntry> emblems = new();
        List<DegreeEntry> degrees = new();
        List<SleeveEntry> sleeves = new();
        List<BattlefieldEntry> battlefields = new();
        List<MyPageBackgroundEntry> myPageBackgrounds = new();
        List<ClassExpEntry> classexp = new();
        List<RankInfoEntry> rankinfos = new();
        
        using (StreamReader reader = new("data/classes.csv"))
        {
            using CsvReader csv = new(reader, CultureInfo.InvariantCulture);
            csv.Context.RegisterClassMap<ClassEntryMap>();
            
            IEnumerable<ClassEntry> records = csv.GetRecords<ClassEntry>();
            classes.AddRange(records);
        }
        
        using (StreamReader reader = new("data/leaderskins.csv"))
        {
            using CsvReader csv = new(reader, CultureInfo.InvariantCulture);
            csv.Context.RegisterClassMap<LeaderSkinEntryMap>();
            
            IEnumerable<LeaderSkinEntry> records = csv.GetRecords<LeaderSkinEntry>();
            leaderSkins.AddRange(records);
            
            leaderSkins.ForEach(skin =>
            {
                if (skin.ClassId == 0)
                {
                    skin.ClassId = null;
                }
            });
        }

        // Load rest of default data
        using (StreamReader reader = new("data/emblems.csv"))
        {
            using CsvReader csv = new(reader, CultureInfo.InvariantCulture);
            csv.Context.RegisterClassMap<EmblemEntryMap>();
    
            IEnumerable<EmblemEntry> records = csv.GetRecords<EmblemEntry>();
            emblems.AddRange(records);
        }
        using (StreamReader reader = new("data/degrees.csv"))
        {
            using CsvReader csv = new(reader, CultureInfo.InvariantCulture);
            csv.Context.RegisterClassMap<DegreeEntryMap>();
    
            IEnumerable<DegreeEntry> records = csv.GetRecords<DegreeEntry>();
            degrees.AddRange(records);
        }
        using (StreamReader reader = new("data/sleeves.csv"))
        {
            using CsvReader csv = new(reader, CultureInfo.InvariantCulture);
            csv.Context.RegisterClassMap<SleeveEntryMap>();
    
            IEnumerable<SleeveEntry> records = csv.GetRecords<SleeveEntry>();
            sleeves.AddRange(records);
        }
        using (StreamReader reader = new("data/battlefields.csv"))
        {
            using CsvReader csv = new(reader, CultureInfo.InvariantCulture);
            csv.Context.RegisterClassMap<BattlefieldEntryMap>();
    
            IEnumerable<BattlefieldEntry> records = csv.GetRecords<BattlefieldEntry>();
            battlefields.AddRange(records);
        }
        using (StreamReader reader = new("data/mypagebackgrounds.csv"))
        {
            using CsvReader csv = new(reader, CultureInfo.InvariantCulture);
            csv.Context.RegisterClassMap<MyPageBackgroundEntryMap>();
    
            IEnumerable<MyPageBackgroundEntry> records = csv.GetRecords<MyPageBackgroundEntry>();
            myPageBackgrounds.AddRange(records);
        }
        using (StreamReader reader = new("data/ranks.csv"))
        {
            using CsvReader csv = new(reader, CultureInfo.InvariantCulture);
            csv.Context.RegisterClassMap<RankInfoEntryMap>();
    
            IEnumerable<RankInfoEntry> records = csv.GetRecords<RankInfoEntry>();
            rankinfos.AddRange(records);
        }
        using (StreamReader reader = new("data/classexp.csv"))
        {
            using CsvReader csv = new(reader, CultureInfo.InvariantCulture);
            csv.Context.RegisterClassMap<ClassExpEntryMap>();
    
            IEnumerable<ClassExpEntry> records = csv.GetRecords<ClassExpEntry>();
            classexp.AddRange(records);
        }

        builder.Entity<ClassEntry>().HasData(classes);
        builder.Entity<LeaderSkinEntry>().HasData(leaderSkins);
        builder.Entity<EmblemEntry>().HasData(emblems);
        builder.Entity<SleeveEntry>().HasData(sleeves);
        builder.Entity<DegreeEntry>().HasData(degrees);
        builder.Entity<BattlefieldEntry>().HasData(battlefields);
        builder.Entity<MyPageBackgroundEntry>().HasData(myPageBackgrounds);
        builder.Entity<RankInfoEntry>().HasData(rankinfos);
        builder.Entity<ClassExpEntry>().HasData(classexp);
    }
}