using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public abstract class CsvData
{
    public List<string> _headers { get; protected set; }
    public string _line { get; set; }
    public string[] _lineElements { get; set; }
    public Dictionary<CsvHeaders, int> _indexes { get; protected set; }
    protected bool _isHeaderSet;
    public bool IsHeaderSet { get { return _isHeaderSet; } }
    protected string ExtractElementFromLine(string[] lineElements, int index)
    {
        string element = index > -1 && index < lineElements.Length ? lineElements[index] : "";
        // remove spaces from the end until a character or a number is found
        if (element.Length > 0 )
        {
            // remove all empty spaces from the end
            element  = element.TrimEnd(' ', '\r', '\'', '\t', '\u200B', '\uFEFF');
        }

        return element;
    }
    protected static int GetIndexFromHeader(List<string> headers, string header)
    {
        if (header == null)
        {
            Debug.LogError("Header is null");
            return -1;
        }

        if (headers.Contains(header))
        {
            return headers.IndexOf(header);
        }
        else
        {
            Debug.LogError("Header does not contain " + header);
            return -1;
        }
    }
    public void ReplaceHeaders(List<string> headers)
    {
        _headers = headers;
        _isHeaderSet = true;
    }
    protected static bool IsHeaderSetInCsv(string firstElement)
    {
        return firstElement == CsvHeaders.Header.ToString() || firstElement == CsvHeaders.ID.ToString();
    }
    protected string GetPrivateValueFirst(string defaultValue, string privateValue)
    {
        return string.IsNullOrEmpty(privateValue) ? defaultValue : privateValue;
    }
    protected static Dictionary<CsvHeaders, int> InitializeIndexesWithHeaders(List<string> headers)
    {
        Dictionary<CsvHeaders, int> indexes = new();

        foreach (var headerName in headers)
        {
            if (string.IsNullOrEmpty(headerName) || headerName == CsvHeaders.Header.ToString())
            {
                continue;
            }

            // Check if the header name exists in the CsvHeaders enum
            var headerEnum = Define.GetHeaderByValue(headerName);
            if (headerEnum == CsvHeaders.NULL) continue;

            //CsvHeaders headerEnum = keys[values.IndexOf(headerName)];
            int index = GetIndexFromHeader(headers, headerName);
            if (index > -1 && !indexes.ContainsKey(headerEnum))
            {
                indexes.Add(headerEnum, index);
            }
        }

        return indexes;
    }
    protected string GetStringRepresentationHeader()
    {
        string headerString = "";
        int i = 0;
        if (_isHeaderSet)
        {
            foreach (var header in _headers)
            {
                string comma = i < _headers.Count - 1 ? "," : "";
                headerString += $"{header}{comma}";
                //headerString += i < Headers.Count - 1 ? $"{}," : $"{header}";
                i++;
            }
        }
        else
        {
            headerString += $"{CsvHeaders.Header.ToString()},";
            foreach (var keyValue in _indexes)
            {
                string comma = i < _headers.Count - 1 ? "," : "";
                headerString += $"{keyValue.Key.ToString()}{comma}";
                //headerString += i < Headers.Count - 1 ? $"{Define.CsvHeaderName[keyValue.Key]}," : $"{Define.CsvHeaderName[keyValue.Key]}";
                i++;
            }

        }
        return headerString;
    }
    protected static (bool isHeaderSet, List<string> headers) SetHeader(List<string> headerElement, bool isHeader)
    {
        for (int j = 0; j < headerElement.Count; j++)
        {
            headerElement[j] = headerElement[j].Replace("\r", "");
        }


        return (IsHeaderSetInCsv(headerElement[0]), headerElement);
    }
    protected static (bool isHeaderSet, List<string> headers) SetHeader(List<string> loadsFromCsv)
    {
        var headerSplit = loadsFromCsv[0].Split(',');
        char[] charsToRemove = { '\r', '\'', ' ', '\t', '\u200B', '\uFEFF' };
        for (int j = 0; j < headerSplit.Length; j++)
        {
            string v = headerSplit[j];

            //for(int k = 0; k < v.Length; k++)
            //{
            //    var c = v[k];
            //    var unicode = Convert.ToInt32(c);
            //}
            //for (int i = 0; i < charsToRemove.Length; i++)
            //{
            //    v = v.Replace(charsToRemove[i].ToString(), "");
            //}
            v = v.TrimStart(charsToRemove);

            headerSplit[j] = v;
        }

        var headers = headerSplit.ToList();

        return (IsHeaderSetInCsv(headers[0]), headers);
    }
    protected static List<T> ExtractTFromCsvToList<T>(List<string> loadsFromCsv, bool isHeaderSet, Dictionary<CsvHeaders, int> indexes, Func<string, T> factory) where T : CsvData
    {
        List<T> datas = new List<T>();
        int i = 0;
        char[] charsToRemove = { '\r', '\'', '\t', '\u200B', '\uFEFF' };
        foreach (var line in loadsFromCsv)
        {
            if (i == 0 && isHeaderSet)
            {
                i++;
                continue;
            }

            var lineSplit = line.Split(',');
            bool empty = true;
            for (int j = 0; j < lineSplit.Length; j++)
            {
                string v = lineSplit[j];
                v = v.TrimStart(charsToRemove);
                lineSplit[j] = v;
                if (empty && !string.IsNullOrEmpty(v))
                {
                    empty = false;
                }
            }
            if (empty) continue;

            string convertedString = string.Join(",", lineSplit);

            if (string.IsNullOrEmpty(convertedString)) continue;

            datas.Add(factory(convertedString));
        }

        return datas;
    }
    protected static Dictionary<string,T> ExtractTFromCsv<T>(List<string> loadsFromCsv, bool isHeaderSet, Dictionary<CsvHeaders, int> indexes, Func<string, T> factory) where T : CsvData
    {
        Dictionary<string, T> datas = new();
        int i = 0;
        char[] charsToRemove = { '\r', '\'', '\t', '\u200B', '\uFEFF' };
        foreach (var line in loadsFromCsv)
        {
            if (i == 0 && isHeaderSet)
            {
                i++;
                continue;
            }

            var lineSplit = line.Split(',');
            bool empty = true;
            for (int j = 0; j < lineSplit.Length; j++)
            {
                string v = lineSplit[j];
                v = v.TrimStart(charsToRemove);
                lineSplit[j] = v;
                if (empty && !string.IsNullOrEmpty(v))
                {
                    empty = false;
                }
            }
            if (empty) continue;

            string convertedString = string.Join(",", lineSplit);

            if (string.IsNullOrEmpty(convertedString)) continue;
            var data = factory(convertedString);
            string dataID = data.GetPropertyValue(CsvHeaders.ID);
            if(string.IsNullOrEmpty(dataID)) continue;

            if (datas.ContainsKey(dataID)) 
            { 
                Debug.Log("Already Contains Key " + dataID); 
                continue; 
            }

            datas.Add(dataID, data);
        }

        return datas;
    }
    public abstract string GetPropertyValue(CsvHeaders header);
    public string GetPropertyValue(string header)
    {
        return GetPropertyValue(Define.GetHeaderByValue(header));
    }
    public abstract Dictionary<string, string> GetFilters();
    public static List<string> GetListStringRepresentationFromList<T>( List<T> datas) where T : CsvData
    {
        bool isHeaderSet = datas[0]._isHeaderSet;
        if (!isHeaderSet)
        {
            Debug.LogError("Missing headers in " + datas[0].GetType());
            return null;
        }

        List<string> stringRepresentation = new List<string>
        {
            datas[0].GetStringRepresentationHeader()
        };

        foreach (var data in datas)
        {
            stringRepresentation.Add(data.GetStringRepresentation());
        }
        return stringRepresentation;
    }
    public static List<string> GetListStringRepresentationFromList<T>(Dictionary<string,T> datas) where T : CsvData
    {
        bool isHeaderSet = datas.FirstOrDefault().Value._isHeaderSet;
        if (!isHeaderSet)
        {
            Debug.LogError("Missing headers in " + datas.FirstOrDefault().Value.GetType());
            return null;
        }

        List<string> stringRepresentation = new List<string>
        {
            datas.FirstOrDefault().Value.GetStringRepresentationHeader()
        };

        foreach (var data in datas)
        {
            stringRepresentation.Add(data.Value.GetStringRepresentation());
        }
        return stringRepresentation;
    }
    public string GetStringRepresentation()
    {
        string output = "";
        if (_isHeaderSet)
        {
            bool isFirstElement = true;
            foreach (string header in _headers)
            {
                string commaSeperation = isFirstElement ? "" : ",";
                isFirstElement = false;

                if (!string.IsNullOrEmpty(header))
                {
                    var propertyValue = GetPropertyValue(header);
                    string propertyValueToString = propertyValue != null ? propertyValue : "";

                    output += commaSeperation + propertyValueToString;
                }
                else
                {
                    output += commaSeperation;
                }
            }
        }
        return output;
    }
}