using System.Collections.Generic;
using UnityEngine;
using Cysharp.Threading.Tasks;
using System.IO;
using System;


public class ConfigBase<U, T> where T : ConfigBase<U, T>, new()
{
    public static Dictionary<U, T> dic = new Dictionary<U, T>();

    public static bool isInit = false;

    public static T Get(U id)
    {
        if (!isInit)
        {
            Debug.LogError("ConfigBase 没有初始化");
            return null; // 或者抛出异常，视情况而定
        }

        if (dic.ContainsKey(id))
        {
            return dic[id];
        }

        return null;
    }

    public static void ForceInit()
    {
        ConfigManager.Instance.LoadConfigByType(typeof(T));
    }

    public List<T> GetValues()
    {
        if (!isInit)
        {
            Debug.LogError(typeof(T).Name + " 没有初始化 GetValues");
            return null; // 或者抛出异常，视情况而定
        }
        List<T> result = new List<T>();
        result.AddRange(dic.Values);
        return result;
    }

    public static bool HasKey(U key)
    {
        if (!isInit)
        {
            Debug.LogError(typeof(T).Name + " 没有初始化 HasKey");
            return false; // 或者抛出异常，视情况而定
        }

        return dic.ContainsKey(key);
    }

    public static void Init(string[] lines)
    {
        dic.Clear();
        
        for (int i = 3; i < lines.Length; i++)
        {
            string line = lines[i];
            var index = line.IndexOf("\t");
            if (index == -1)
            {
                continue;
            }

            string strKey = line.Substring(0, index);
            T config = new T();
            U key = config.LoadKey(strKey);
            config.LoadConfig(line);
            #if UNITY_EDITOR
            try
            {
            #endif
            dic.Add(key, config);
            #if UNITY_EDITOR
            }
            catch (ArgumentException exception)
            {
                Debug.LogError(typeof(T).Name  + " 重复的key " + key + " " + exception.Message);
            }
            #endif
            
        }

        isInit = true;
    }

    public virtual U LoadKey(string line)
    {
        return default(U);
    }

    public virtual void LoadConfig(string line)
    {
        
    }
    
    protected int ParseInt(string str)
    {
        int result = 0;
        int.TryParse(str, out result);
        return result;
    }

    protected float ParseFloat(string str)
    {
        float result = 0f;
        float.TryParse(str, out result);
        return result;
    }

    protected string[] Split(string str, char split)
    {
        return str.Split(split);
    }

    protected List<string> ParseStrList(string str, char split)
    {
        List<string> result = new List<string>();
        string[] strs = Split(str, split);
        for (int i = 0; i < strs.Length; i++)
        {
            result.Add(strs[i]);
        }

        return result;
    }

    protected List<int> ParseIntList(string str, char split)
    {
        List<int> result = new List<int>();
        string[] strs = Split(str, split);
        for (int i = 0; i < strs.Length; i++)
        {
            result.Add(ParseInt(strs[i]));
        }
        return result;
    }

    protected U GetKey(string key)
    {
        if (typeof(U) == typeof(string))
        {
            return (U)(object)key;
        }
        else if (typeof(U) == typeof(int))
        {
            return (U)(object)ParseInt(key);
        }
        else
        {
            Debug.LogError("GetKey 意外的key类型 类型错误 " + typeof(U).Name);
            return default(U);
        }
    }
}