using BLL;
using ClosedXML.Excel;
using Model;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BLL
{
    public class ExtraFileData
    {
        public delegate Dictionary<string, string> DataSelectDelegate(string datakey, List<Dictionary<string, string>> dataList);
        public static event DataSelectDelegate DataSelectingEvent;

        public static Dictionary<string, List<Dictionary<string, string>>> AllData = new Dictionary<string, List<Dictionary<string, string>>>();
        public static List<string> Titles = new List<string>();

        public static List<string> DataTitle = new List<string>();
        public static void Init()
        {
            var ext = Path.GetExtension(Config.DataSource_FilePath);
            if (string.IsNullOrEmpty(ext))
            {
                return;
            }
            ext = ext.ToLower();
            AllData.Clear();
            if (ext == ".xlsx")
                LoadXLSALlData();
            else if (ext == ".csv")
                LoadCSVALlData();
        }
        public static void LoadCSVALlData()
        {
            LogNet.log.Info("数据源:" + Config.DataSource_FilePath);
            if (!File.Exists(Config.DataSource_FilePath))
            {
                return;
                throw new FileNotFoundException(Config.DataSource_FilePath);
            }
            Titles = ParseCSVFileTitle(Config.DataSource_FilePath);
            //Common.extraKey = titles;
            string[] files;
            if (Config.DataSource_Recursive)
            {
                var ext = Path.GetExtension(Config.DataSource_FilePath);
                var path = Path.GetDirectoryName(Config.DataSource_FilePath);
                files = Directory.GetFiles(path, "*" + ext);
            }
            else
            {
                files = new string[] { Config.DataSource_FilePath };
            }

            DataTitle.Clear();
            AllData.Clear();
            foreach (var file in files)
            {
                LogNet.log.Info("数据源加载文件:" + file);
                try
                {
                    using var sm = new StreamReader(file, Encoding.GetEncoding(Config.DataSource_Encoding));
                    while (true)
                    {
                        var dataline = sm.ReadLine();
                        if (string.IsNullOrWhiteSpace(dataline))
                            break;
                        var datas = ParseCsvLine(dataline);
                        if (datas.Length < Titles.Count)
                            continue;
                        string keydata = "";
                        var rowdata = new Dictionary<string, string>();
                        for (int i = 0; i < Titles.Count; i++)
                        {
                            rowdata.Add(Titles[i], datas[i]);
                            if (Titles[i] == Config.DataSource_DataTitle)
                            {
                                keydata = datas[i];
                            }
                        }
                        if (!string.IsNullOrEmpty(keydata))
                        {
                            List<Dictionary<string, string>> keyList = new List<Dictionary<string, string>>() { };
                            if (AllData.ContainsKey(keydata))
                            {
                                keyList = AllData[keydata];
                                keyList.Add(rowdata);
                                AllData[keydata] = keyList;
                            }
                            else
                            {
                                keyList.Add(rowdata);
                                AllData.Add(keydata, keyList);
                                DataTitle.Add(keydata);
                            }
                        }

                    }
                }
                catch (Exception ex)
                {
                    LogNet.log.Info("数据源加载文件出错:" + ex.ToString());
                }
            }
            //Common.extraData = AllData;
        }
        public static List<string> ParseCSVFileTitle(string filename)
        {
            if (!File.Exists(filename))
                return new List<string>();

            using var sm = new StreamReader(filename, Encoding.GetEncoding(Config.DataSource_Encoding.Val));
            var titleline = sm.ReadLine();
            var titles = new List<string>(ParseCsvLine(titleline));
            return titles;
        }

        private static string[] ParseCsvLine(string line)
        {
            List<string> result = new List<string>();
            try
            {
                if (string.IsNullOrEmpty(line))
                    return new string[0];

                StringBuilder currentStr = new StringBuilder();
                bool inQuotes = false;

                for (int i = 0; i < line.Length; i++)
                {
                    char c = line[i];
                    if (c == '\"')
                    {
                        if (inQuotes && i + 1 < line.Length && line[i + 1] == '\"')
                        {
                            currentStr.Append('\"');
                            i++;
                        }
                        else
                        {
                            inQuotes = !inQuotes;
                        }
                    }
                    else if (c == ',' && !inQuotes)
                    {
                        result.Add(currentStr.ToString());
                        currentStr.Clear();
                    }
                    else
                    {
                        currentStr.Append(c);
                    }
                }
                result.Add(currentStr.ToString());

            }
            catch (Exception ex)
            {
                LogNet.log.Error("ParseCsvLine,line=" + line + " 出错：" + ex.ToString());
            }
            return result.ToArray();
        }


        public static void LoadXLSALlData()
        {
            if (!File.Exists(Config.DataSource_FilePath))
            {
                return;
                //throw new FileNotFoundException(Config.DataSource_String);
            }
            Titles = ParseXLSFileTitle(Config.DataSource_FilePath);
            //Common.extraKey = titles;

            string[] files;
            if (Config.DataSource_Recursive)
            {
                var ext = Path.GetExtension(Config.DataSource_FilePath);
                var path = Path.GetDirectoryName(Config.DataSource_FilePath);
                files = Directory.GetFiles(path, "*" + ext);
            }
            else
            {
                files = new string[] { Config.DataSource_FilePath };
            }
            DataTitle.Clear();
            AllData.Clear();
            foreach (var file in files)
            {
                LogNet.log.Info("数据源加载文件:" + file);
                try
                {
                    XLWorkbook wb = new XLWorkbook(file);
                    IXLWorksheet ws = wb.Worksheet(1);
                    int emptyrow = 0;
                    int currow = 0;
                    while (emptyrow < 100)
                    {
                        string keydata = "";
                        var rowdata = new Dictionary<string, string>();
                        for (int i = 0; i < Titles.Count; i++)
                        {
                            var v = ws.Row(currow + 1).Cell(i + 1).Value.ToString().Trim();
                            rowdata.Add(Titles[i], v);
                            if (Titles[i] == Config.DataSource_DataTitle)
                            {
                                keydata = v;
                                if (string.IsNullOrWhiteSpace(v))
                                    emptyrow++;
                            }
                        }

                        if (!string.IsNullOrEmpty(keydata))
                        {
                            List<Dictionary<string, string>> keyList = new List<Dictionary<string, string>>() { };
                            if (AllData.ContainsKey(keydata))
                            {
                                keyList = AllData[keydata];
                                keyList.Add(rowdata);
                                AllData[keydata] = keyList;
                            }
                            else
                            {
                                keyList.Add(rowdata);
                                AllData.Add(keydata, keyList);
                                DataTitle.Add(keydata);
                            }
                        }
                        if (string.IsNullOrEmpty(keydata))
                            emptyrow++;

                        currow++;
                    }
                }
                catch (Exception ex)
                {
                    LogNet.log.Info("数据源加载文件出错:" + ex.ToString());
                }
            }
            //Common.extraData = AllData;
        }
        public static List<string> ParseXLSFileTitle(string filename)
        {
            List<string> titles = new List<string>();
            int emptycolcount = 0;

            if (!File.Exists(filename))
                return titles;
            LogNet.log.Info("filename:" + filename);
            XLWorkbook wb = new XLWorkbook(filename);
            IXLWorksheet ws = wb.Worksheet(1);
            for (int i = 1; i < 50; i++)
            {
                var v = ws.Row(1).Cell(i).Value.ToString().Trim();
                if (string.IsNullOrEmpty(v))
                {
                    emptycolcount++;
                    if (emptycolcount > 3)
                    {
                        break;
                    }
                }
                if (!string.IsNullOrEmpty(v))
                {
                    titles.Add(v);
                }
            }
            return titles;
        }


        public static Encoding GetEncoding(string coding)
        {
            try
            {
                return Encoding.GetEncoding(coding);
            }
            catch
            {
                return Encoding.UTF8;
            }
        }

        public static Dictionary<string, string> GetSelectDataSource(string dataKey)
        {
            List<Dictionary<string, string>> aExtraData = ExtraFileData.AllData[dataKey];
            if (aExtraData.Count == 1)
            {
                return aExtraData[0];
            }

            else if (Config.DataSource_MultilineMode.Val == true)
            {
                if (DataSelectingEvent == null)
                {
                    LogNet.log.Info("匹配到数据源:" + dataKey + " 共有 " + aExtraData.Count + "条数据，默认使用第一条数据");
                    return aExtraData[0];
                }

                LogNet.log.Info("匹配到数据源:" + dataKey + " 共有 " + aExtraData.Count + "条数据，弹框让用户选择");
                Dictionary<string, string> selecValue = DataSelectingEvent?.Invoke(dataKey, aExtraData);
                return selecValue;
            }
            else
            {
                return null;
            }
        }
        public static bool hasFileData()
        {
            return AllData != null && AllData.Count > 0;
        }


        private static Dictionary<string, string> GetOtherKeys()
        {
            Dictionary<string, string> otherKeys = new Dictionary<string, string>();
            try
            {
                if (Config.DataSource_DataKey_Others.Val != null && Config.DataSource_DataKey_Others.Val.Length > 0)
                {
                    string[] keys = Config.DataSource_DataKey_Others.Val;
                    foreach (string key in keys)
                    {
                        bool add = false;
                        if (key.Contains("="))
                        {
                            string[] paramArray = key.Split('=');
                            if (paramArray.Length == 2)
                            {
                                otherKeys.Add(paramArray[0], paramArray[1]);
                                add = true;
                            }
                        }
                        if (!add)
                        {
                            otherKeys.Add(key, key);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogNet.log.Info("GetOtherKeys 获取其他字段出错:" + ex.ToString());
            }
            return otherKeys;
        }

        /// <summary>
        /// 匹配数据源
        /// </summary>
        /// <param name="key"></param>
        /// <param name="findOk"></param>
        /// <returns></returns>
        public static Dictionary<string, string> MatchFileData(Dictionary<string, string> key, out bool findOk)
        {
            findOk = false;
            try
            {

                //使用key填充时，请处理字段开头的<OCR>字段
                //查询excel数据填充

                if (key.ContainsKey(Config.DataSource_DataKey))
                {
                    string CleanData = key[Config.DataSource_DataKey].Replace("<OCR>", "");
                    if (key.ContainsKey(Config.DataSource_DataKey) && ExtraFileData.AllData.ContainsKey(CleanData))
                    {
                        var extraData = ExtraFileData.GetSelectDataSource(CleanData);
                        if (extraData != null)
                        {
                            findOk = true;
                            Dictionary<string, string> otherKeys = GetOtherKeys();
                            key = UpdateData(key, extraData, otherKeys);
                            LogNet.log.Info("匹配到数据源:" + Config.DataSource_DataKey + "=" + CleanData + "  数据: " + JsonConvert.SerializeObject(extraData));
                            return key;
                        }
                    }
                }
                if (!findOk && Config.DataSource_DataKey_Others.Val != null && Config.DataSource_DataKey_Others.Val.Length > 0)
                {
                    Dictionary<string, string> otherKeys = GetOtherKeys();
                    foreach (string oKey in otherKeys.Keys)
                    {
                        if (!key.ContainsKey(oKey))
                        {
                            continue;
                        }
                        string CleanData = key[oKey].Replace("<OCR>", "");
                        if (String.IsNullOrEmpty(CleanData))
                        {
                            continue;
                        }
                        string titleValue = otherKeys[oKey];

                        //循环所有数据
                        if (titleValue == Config.DataSource_DataTitle && ExtraFileData.AllData.ContainsKey(CleanData))
                        {
                            var extraData = ExtraFileData.GetSelectDataSource(CleanData);
                            if (extraData != null)
                            {
                                findOk = true;
                                key = UpdateData(key, extraData, otherKeys);
                                LogNet.log.Info("匹配到数据源:" + titleValue + "=" + CleanData + " 数据: " + JsonConvert.SerializeObject(extraData));
                                break;
                            }
                        }
                        else
                        {
                            List<Dictionary<string, string>> findData = new List<Dictionary<string, string>>();
                            //查找其他列
                            foreach (List<Dictionary<string, string>> sourceData in AllData.Values)
                            {

                                foreach (Dictionary<string, string> data in sourceData)
                                {
                                    if (data.ContainsKey(titleValue))
                                    {
                                        string vstring = data[titleValue];
                                        if (vstring.Trim().Equals(CleanData.Trim()))
                                        {
                                            findData.Add(data);
                                        }
                                    }
                                }
                            }
                            if (findData.Count > 0)
                            {
                                var findDataMap = new Dictionary<string, string>();
                                if (findData.Count == 1)
                                { 
                                    findDataMap = findData[0];
                                    LogNet.log.Info("匹配到数据源:" + titleValue + "=" + CleanData + " 共有 " + 1 + "条数据: " + JsonConvert.SerializeObject(findData[0]));
                                }
                                else if (Config.DataSource_MultilineMode.Val == true)
                                {
                                    if (DataSelectingEvent == null)
                                    {
                                        LogNet.log.Info("匹配到数据源:" + titleValue + "=" + CleanData + " 共有 " + findData.Count + "条数据，默认使用第一条数据");
                                        findDataMap = findData[0]; 
                                    }
                                    else
                                    {
                                        LogNet.log.Info("匹配到数据源:" + titleValue + "=" + CleanData + " 共有 " + findData.Count + "条数据，弹框让用户选择");
                                        findDataMap = DataSelectingEvent?.Invoke(titleValue + "=" + CleanData, findData);                                      
                                    }
                                }
                                if (findDataMap != null && findDataMap.Count > 0)
                                {
                                    findOk = true; 
                                    key = UpdateData(key, findDataMap, otherKeys);
                                    break;
                                } 
                            }
                             
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogNet.log.Error("MatchFileData 出错：" + ex.ToString());
            }
            return key;

        }

        private static  Dictionary<string,string> UpdateData(Dictionary<string, string> key,Dictionary<string,string> findDataMap,Dictionary<string,string> otherKeys)
        {
            Dictionary<string, List<string>> titleKey = new Dictionary<string, List<string>>();
            foreach (string otherKey in otherKeys.Keys)
            {
                string value = otherKeys[otherKey];
                List<string> mcodes = new List<string>();
                titleKey.TryGetValue(value, out mcodes);
                if (mcodes == null)
                {
                    mcodes = new List<string>();
                }
                mcodes.Add(otherKey);
                titleKey[value] = mcodes;
            }


            foreach (var d in findDataMap)
            {
                if (!string.IsNullOrEmpty(d.Value))
                {
                    if (titleKey.ContainsKey(d.Key))
                    {
                        foreach(string  softKey in titleKey[d.Key])
                        { 
                            key[softKey] = d.Value;
                        }
                    }
                    else
                    {
                        key[d.Key] = d.Value;
                    }

                }
            }
            return key;
        }
    }
}