using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows.Forms;
using TSA_V.Common;
using TSA_V.DeviceLibrary;

namespace TSA_V.LoadCSVLibrary
{
    public class CSVBomManager : CSVReaderBase
    {

        /// <summary>
        /// 所有的位置集合，key=位置
        /// </summary>
        public static Dictionary<string, List< ComponetInfo>> allComMap = new Dictionary<string, List<ComponetInfo>>();

        public static List<ComponetInfo> GetComList(string bomName)
        {
            if (allComMap.ContainsKey(bomName))
            {
                return new List<ComponetInfo>(allComMap[bomName]);
            }
            else
            {
                string fileName = getFilePath(bomName);
                if (File.Exists(fileName))
                {
                    List<ComponetInfo> list = ReadFile(fileName);
                    allComMap.Add(bomName, list);
                    return list;
                }
            }

            LogUtil.error("bomName=" + bomName + " 未找到元器件列表");

            return new List<ComponetInfo>();
        }

        public static bool BomNameIsExists(string bomName)
        {
            if (allComMap.ContainsKey(bomName))
            {
                return true;
            } 
            return false;
        }

        public static void LoadAllCom()
        {

            allComMap = new Dictionary<string, List<ComponetInfo>>();
            string appPath = Application.StartupPath;
            string filePath = appPath + ConfigAppSettings.GetValue(Setting_Init.ComPath_Config);
            if (!Directory.Exists(filePath))
            {
                Directory.CreateDirectory(filePath);
            }
            //加载所有数据
            string[] fileList = Directory.GetFiles(filePath);
            if (fileList.Length <= 0)
            {
                return;
            }
            foreach (string fileName in fileList)
            {
                try
                {
                    string extension = Path.GetExtension(fileName); //-->.xml
                    if (extension.ToLower().Equals(".csv"))
                    {
                        string bomName = Path.GetFileNameWithoutExtension(fileName); //-->BenXHCMS 
                        List<ComponetInfo> list = ReadFile(fileName);
                        if (list.Count > 0)
                        {
                            allComMap.Add(bomName, list);
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error("加载出错：" + ex.ToString());
                }
            }
        }

        public  static string getFilePath(string bomName)
        {
            string appPath = Application.StartupPath;
            string filePath = appPath + ConfigAppSettings.GetValue(Setting_Init.ComPath_Config);
            return filePath + bomName + ".csv";
        }
        /// <summary>
        /// 解析一行CSV数据
        /// </summary>
        /// <param name="csv">csv数据行</param>
        /// <returns></returns>
        public static string[] FromCsvLine(string csv)
        {

            var newstr = string.Empty;
            List<string> sList = new List<string>();

            bool isSplice = false;
            string[] array = csv.Split(new char[] { ',' });
            foreach (var str in array)
            {
                if (!string.IsNullOrEmpty(str) && str.IndexOf('"') > -1)
                {
                    var firstchar = str.Substring(0, 1);
                    var lastchar = string.Empty;
                    if (str.Length > 0)
                    {
                        lastchar = str.Substring(str.Length - 1, 1);
                    }
                    if (firstchar.Equals("\"") && !lastchar.Equals("\""))
                    {
                        isSplice = true;
                    }
                    if (lastchar.Equals("\""))
                    {
                        if (!isSplice)
                            newstr += str;
                        else
                            newstr = newstr + "," + str;

                        isSplice = false;
                    }
                }
                else
                {
                    if (string.IsNullOrEmpty(newstr))
                        newstr += str;
                }

                if (isSplice)
                {
                    //添加因拆分时丢失的逗号
                    if (string.IsNullOrEmpty(newstr))
                        newstr += str;
                    else
                        newstr = newstr + "," + str;
                }
                else
                {
                    sList.Add(newstr.Replace("\"", "").Trim());//去除字符中的双引号和首尾空格
                    newstr = string.Empty;
                }
            }
            return sList.ToArray();

        }
        /// <summary>
        /// 反转字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static string Reverse(string str)
        {
            string revStr = string.Empty;
            foreach (char chr in str)
            {
                revStr = chr.ToString() + revStr;
            }
            return revStr;
        }
        /// <summary>
        /// 替换CSV中的双引号转义符为正常双引号,并去掉左右双引号
        /// </summary>
        /// <param name="csvValue">csv格式的数据</param>
        /// <returns></returns>
        private static string ReplaceQuote(string csvValue)
        {
            string rtnStr = csvValue;
            if (!string.IsNullOrEmpty(csvValue))
            {
                //首尾都是"
                Match m = Regex.Match(csvValue, "^\"(.*?)\"$");
                if (m.Success)
                {
                    rtnStr = m.Result("${1}").Replace("\"\"", "\"");
                }
                else
                {
                    rtnStr = rtnStr.Replace("\"\"", "\"");
                }
            }
            return rtnStr;

        }
         
        /// <summary>
        /// 添加一个csv文件的数据到位置集合中
        /// </summary>
        /// <param name="filePath">cvs文件路径+文件名</param>  
        /// <returns></returns>
        public static List<ComponetInfo> ReadFile(string filePath,Dictionary<string,string> titleMap=null)
        {
            if (titleMap == null)
            {
                titleMap = new Dictionary<string, string>();
            }
            System.Type type = typeof(ComponetInfo);
            List<ComponetInfo> comList = new List<ComponetInfo>();
            Dictionary<string, List<string>> proTitleMap = getProAttributeMaps(typeof(ComponetInfo));
            foreach(string key in titleMap.Keys)
            {
                string value= titleMap[key];
                if (proTitleMap.ContainsKey(key))
                {
                    if (!proTitleMap[key].Contains(value))
                    {
                        proTitleMap[key].Add(value); 
                    }
                }
                else
                {
                    proTitleMap.Add(key, new List<string>() { value });
                }
            }

            //List<string> cvsTitleList = new List<string>(proTitleMap.Values);
            List<string> propertyList = new List<string>(proTitleMap.Keys);

            string[] lines = ReadCSVFile(filePath);
            int index = 0;
            Dictionary<string, int> propIndexMap = new Dictionary<string, int>();
            foreach (var line in lines)
            {
                var newLine = line.Replace("\"", "");
                var array = newLine.Split(Spilt_Char);
                array = FromCsvLine(line);
                if (index == 0)
                {
                    propIndexMap = GetProTitleIndex(line, proTitleMap);
                }
                else
                {
                    try
                    {
                        if (array.Length >= propIndexMap.Count|| (titleMap.Count>0&&array.Length> titleMap.Count))
                        {
                            //if (array.Length > 0 && array[0].Equals(""))
                            //{
                            //    continue;
                            //}
                            var bllIns = type.Assembly.CreateInstance(type.FullName);
                            //取得属性集合
                            PropertyInfo[] props = type.GetProperties();

                            int listIndex = 0;

                            foreach (string proName in propertyList)
                            {
                                if (propIndexMap.ContainsKey(proName))
                                {
                                    int titIndex = propIndexMap[proName];
                                    string value = array[titIndex];
                                    //string proName = propertyList[listIndex];
                                    PropertyInfo prop = props.First(c => c.Name == proName);//获取同名属性
                                    if (prop != null)
                                    {
                                        string typeName = prop.PropertyType.Name;
                                        //判断值是否为空
                                        if (value.Equals("") && (typeName.ToUpper().Equals("INT32") || typeName.ToUpper().Equals("DOUBLE")))
                                        {
                                            value = "0";
                                        }
                                        //if (proName == "PositionX" || proName == "PositionY") {
                                        //    value = Regex.Match(value, @"\d+\.\d+|\d+").Value;
                                        //    if (value == "")
                                        //        value = "0";                                        
                                        //}

                                        //如果属性存在
                                        prop.SetValue(bllIns, Convert.ChangeType(value, prop.PropertyType), null);//赋值****在这里需要考虑类型问题 
                                    }
                                }
                                listIndex++;
                            }
                            ComponetInfo com = (ComponetInfo)bllIns;
                            com.Id = index ;
                            comList.Add(com);
                        }
                        else
                        {
                            LOGGER.Error("读取csv，index=" + index + ",数据格式不匹配！，line=" + line);
                        }
                    }
                    catch (Exception ex)
                    {
                        LOGGER.Debug("CSV 读取行【" + line + "】行转换失败");
                    }
                }
                index++;
            }


            return CreateCompone(comList);
        }


        public static List<ComponetInfo> CreateCompone(List<ComponetInfo> comList)
        {
            Dictionary<string, string> pnposlist = new Dictionary<string, string>();
            HashSet<string> usedposlist = new HashSet<string>();
            List<ComponetInfo> componetlist = new List<ComponetInfo>();
            #region 将解析好的excel内容，生成到List<ComponetInfo>中            
            int Id = 1;
            foreach (var com in comList)
            {
                if (string.IsNullOrWhiteSpace(com.PositionNum)) continue;

                string[] strarr = GetPositionNum(com.PositionNum);
                string[] intarr = com.ComCount.Split(';');
                
                if (strarr.Length != intarr.Length)
                {
                    LogUtil.error($"{com.PN}的数量分组{intarr.Length}和位置分组{strarr.Length}，不统一！");
                    return new List<ComponetInfo>();
                }else if (strarr.Length > 1)
                { 
                    LogUtil.error($"{com.PN}的数量分组{intarr.Length}和位置分组{strarr.Length}");
                }

                for (int j = 0; j < strarr.Length; j++)
                {
                    componetlist.Add(new ComponetInfo
                    {
                        Id = (j==0)?Id:-1,
                        TagNo = com.TagNo,
                        PositionX = com.PositionX,
                        PositionY= com.PositionY,
                        PositionNum = strarr[j],
                        PN = com.PN,
                        Text = com.Text,
                        ComCount = intarr[j],
                        ComponentDes = com.ComponentDes,
                        Notes = com.Notes
                    });
                }

                Id ++ ;
                if (!string.IsNullOrEmpty(com.PositionNum))
                {
                    usedposlist.Add(com.PositionNum);
                    pnposlist[com.PN] = com.PositionNum;
                }
            }
            #endregion
            foreach (var com in componetlist)
            {

                if (string.IsNullOrWhiteSpace(com.PositionNum) && !string.IsNullOrWhiteSpace(com.PN))
                {
                    if (pnposlist.ContainsKey(com.PN))
                        com.PositionNum = pnposlist[com.PN];
                    else
                    {
                        foreach (var p in CSVPositionReader<TSAVPosition>.allPositionMap)
                        {
                            if (usedposlist.Contains(p.Value.PositionNum))
                                continue;
                            com.PositionNum = p.Value.PositionNum;
                            pnposlist[com.PN] = com.PositionNum;
                            usedposlist.Add(com.PositionNum);
                            break;
                        }
                    }
                }
                //if (String.IsNullOrEmpty(com.PositionNum) || String.IsNullOrEmpty(com.PN))
                //{
                //    LOGGER.Error("读取csv，数据不完整，跳过数据，line=" + com.TagNo);
                //    continue;
                //}
            }
            return componetlist;
        }
        public static string[] GetPositionNum(string configPosition )
        {
            string[] strings=configPosition.Split(';');
            string[] strarr=new string[strings.Length];
            int i = 0;
            foreach (var item in strings)
            {
                TSAVPosition p = CSVPositionReader<TSAVPosition>.GetPositonByNum(item);
                if (p != null)
                {
                   // return p.PositionNum;
                    strarr[i] = p.PositionNum;
                }
                else
                {
                    strarr[i] = "";
                }
                i++;
            }
            return strarr;
        }
        

        public static bool UpdateComponet(string bomName, ComponetInfo com,bool updateImage=false )
        {
            if (!allComMap.ContainsKey(bomName))
            {
                return false;
            }
            List<ComponetInfo> oldList = allComMap[bomName];
            for (int index = 0; index < oldList.Count; index++)
            {
                if (oldList[index].IsSameCom(com))
                {
                    oldList[index] = com;
                    if (!updateImage)
                    {

                        break;
                    }
                }else if (updateImage && oldList[index].PN.Equals(com.PN))
                {
                    oldList[index].imgInfo = null;
                }
            }
           

            if (SaveBomToFile(bomName, oldList))
            {
                allComMap[bomName] = oldList;
                return true;
            }

            return false;
        }

        public static bool SaveBomToFile(string bomName, List<ComponetInfo> positionList,string filePath="")
        {
            if (filePath == "")
            {
                filePath = getFilePath(bomName);
            } 
              
            System.Type type = typeof(ComponetInfo); 
            Dictionary<string, List<string>> proTitleMap = getProAttributeMaps(typeof(ComponetInfo));
           
            List<string> propertyList = new List<string>(proTitleMap.Keys);
            Dictionary<string, int> propIndexMap = new Dictionary<string, int>();
            string[] lines = new string[positionList.Count + 1];
            if (File.Exists(filePath))
            { 
                string[] readLines = ReadCSVFile(filePath);
                foreach (var line in readLines)
                {
                    lines[0] = line;
                    var array = line.Split(',');
                    propIndexMap = GetProTitleIndex(line, proTitleMap);
                    break;
                }
            }
            else
            {
                string line = "";
                propIndexMap = new Dictionary<string, int>();
                int proIndex = 0;
                   foreach(string pro in propertyList)
                {
                    List<string> csvList = proTitleMap[pro];
                    string title = csvList[0];
                    propIndexMap.Add(pro, proIndex);
                    line += title + ",";
                    proIndex++;
                }

                lines[0] = line;

            }
            int index = 1;

            foreach (ComponetInfo position in positionList)
            {
                string newValue = ObjToString(position, propIndexMap);
                lines[index] = newValue;
                index++;
            }

            return WriteCSVFile(filePath, lines);
        }

     

        private static string ObjToString(ComponetInfo position, Dictionary<string, int> propIndexMap)
        {
            //取得属性集合
            PropertyInfo[] props = typeof(ComponetInfo).GetProperties(); 
            List<string> propertyList = new List<string>(propIndexMap.Keys);
            String[] array = new String[propIndexMap.Count];

            foreach (string proName in propertyList)
            {
                try
                {
                    PropertyInfo prop = props.First(c => c.Name == proName);//获取同名属性
                    if (prop != null)
                    {//如果属性存在
                        string value = prop.GetValue(position, null).ToString();
                        int index = propIndexMap[proName];
                        array[index] = value;
                    }

                }
                catch (Exception ex)
                {
                    LogUtil.error(ex.ToString());
                }
            }

            string newStr = "";
            foreach (string str in array)
            {
                newStr += str + Spilt_Char;
            }
            return newStr;
        }
         
        public static bool AddBom(string bomName, List<ComponetInfo> comList)
        {
            try
            {
                RemoveBom(bomName);
                string filePath = getFilePath(bomName);
                if (File.Exists(filePath))
                {
                    //删除原来的文件
                    File.Delete(filePath);
                    LogUtil.error("新增元器件库：" + bomName + ",发现文件【" + filePath + "】已存在，删除原来的文件");
                } 
 
                allComMap.Add(bomName, comList);
                return SaveBomToFile(bomName, comList);
            }
            catch (Exception ex)
            {
                LogUtil.error("增加元器件库出错 ：【" + bomName + "】" + ex.ToString());
                return false;
            }
        }
         
        public static void RemoveBom(string bomName)
        {
            try
            {
                string fileName = getFilePath(bomName);
                if (allComMap.ContainsKey(bomName))
                {
                    allComMap.Remove(bomName);
                }
                if (File.Exists(fileName))
                {
                    File.Delete(fileName);
                }
                //删除图片文件夹
                string filePath = Path.Combine(Setting_NInit.Device_ComImagePath, @"/" + bomName);
                if (Directory.Exists(filePath))
                {
                    Directory.Delete(filePath);
                }

            }
            catch (Exception ex)
            {
                LogUtil.error("RemoveBom " + bomName + "出错：" + ex.ToString());
            }
        }

        public static List<ComponetInfo> RemoveCom(string bomName, ComponetInfo obj)
        {
            string fileName = getFilePath(bomName);
            File.Delete(bomName);
            if (allComMap.ContainsKey(bomName))
            {
                int delIndex = -1;
                List<ComponetInfo> list = allComMap[bomName];
                for (int index = 0; index < list.Count; index++)
                {
                    if (list[index].IsSameCom(obj))
                    {
                        delIndex = index;
                        break;
                    }
                }
                if (delIndex >= 0)
                {
                    list.RemoveAt(delIndex);
                    for (int i = 0; i < list.Count; i++)
                    {
                        list[i].Id = i + 1;
                    }
                    AddBom(bomName, list);
                }
                return list;

            }

            return null;
        }
        public static List<ComponetInfo> AddCom(string bomName, ComponetInfo obj)
        {
            string fileName = getFilePath(bomName);
            File.Delete(bomName);
            if (allComMap.ContainsKey(bomName))
            {
                List<ComponetInfo> list = allComMap[bomName];
                list.Add(obj);
                for(int i = 0; i < list.Count; i++)
                {
                    list[i].Id = i + 1;
                }
                AddBom(bomName, list);
                LogUtil.info($"元器件库[{bomName}]新增元器件[{obj.TagNo}-{obj.PN}]");

                ////更新此元器件库对应的程序
                //BoardManager.AddCom(bomName, obj);

                return list;
            }

            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="bomName"></param>
        /// <param name="pointInfo"></param>
        /// <param name="issamecom">为true时执行新的查询元器件库逻辑，不影响之前的引用逻辑</param>
        /// <returns></returns>
        public static ComponetInfo GetCom(string bomName, SMTPointInfo pointInfo,bool issamecom=false)
        {
            if (allComMap.ContainsKey(bomName))
            {
                List<ComponetInfo> map = allComMap[bomName];
                foreach (ComponetInfo obj in map)
                {
                    if (issamecom)
                    {
                        if (obj.IsSameComAndCount(pointInfo))
                        {
                            return obj;
                        }
                    }
                    else
                    {
                        if (obj.IsSameCom(pointInfo))
                        {
                            return obj;
                        }
                    }
                   
                }
                foreach (ComponetInfo obj in map)
                {
                    if (obj.PN.Equals(pointInfo.PN))
                    {
                        return obj;
                    }
                }
            }
            return null;
        }


        public static List<ComponetInfo> GetComsByPN(string bomName, string pn)
        {
            List<ComponetInfo> list = new List<ComponetInfo>();
            if (allComMap.ContainsKey(bomName))
            {
                List<ComponetInfo> map = allComMap[bomName];
                list = (from m in map where m.PN.Equals(pn) select m).ToList();
            }
            return list;
        }

        public static bool canRemoveCom(string bomName, ComponetInfo obj)
        {
            List<ComponetInfo> list = CSVBomManager.GetComList(bomName);
            //已使用的元器件不能删除
            foreach (BoardInfo board in BoardManager.boardList)
            {
                if (board.bomName.Equals(bomName))
                {
                    foreach (SMTPointInfo p in board.smtList)
                    {
                        if ((!String.IsNullOrEmpty(obj.TagNo)))
                        {
                            if (p.TagNo.Equals(obj.TagNo))
                            {
                                return false;
                            }
                        }
                        else if (p.PN.Equals(obj.PN))
                        {
                            List<ComponetInfo> pnlist = (from m in list where m.Id != obj.Id && m.PN.Equals(p.PN) select m).ToList();
                            if (pnlist.Count <= 0)
                            {
                                return false;
                            }
                        }
                    }

                }
            }
            return true;
        }

        /// <summary>
        /// 更新元器件数量，优先用位号查找，未找到时用Pn查找
        /// </summary> 
        public static bool UpdateCount(string bomName, SMTPointInfo smtPoint, int count)
        {
            List<ComponetInfo> comList = CSVBomManager.GetComList(bomName);
            if (comList == null)
            {
                return false;
            } 

            bool updateOk = false;
           for(int i=0;i<comList.Count;i++)
            {
                if (comList[i].IsSameCom(smtPoint))
                {
                    comList[i].ComCount = count.ToString();
                    updateOk = true;
                    break;
                }  
            }

            if (!updateOk)
            {
                for (int i = 0; i < comList.Count; i++)
                {
                    if (comList[i].PN.Equals(smtPoint.PN))
                    {
                        comList[i].ComCount = count.ToString();
                        updateOk = true;
                        break;
                    }
                }
            }

            CSVBomManager.SaveBomToFile(bomName, comList);
            return true;
        }
        /// <summary>
        /// 减去此电路板使用的元器件数量
        /// </summary>
        /// <param name="currBoard"></param>
        public static bool DelUseCount(DeviceLibrary.BoardInfo currBoard, List<ComponetInfo> useComponets)
        {
            try
            {
                //如果禁用数量功能，不更改
                if (!Setting_NInit.Device_UsePNCount)
                {
                    return true ;
                }
                string bomName = currBoard.bomName;
                List<ComponetInfo> comList = CSVBomManager.GetComList(bomName);
                if (comList == null)
                {
                    return false;
                } 
                List<ComponetInfo> newList = new List<ComponetInfo>();
                foreach (ComponetInfo obj in comList)
                { 
                    List<ComponetInfo> list = (from m in useComponets where m.Id.Equals(obj.Id) select m).ToList(); 
                    if (list.Count > 0)
                    {
                        obj.ComCount = (obj.GetCount() - list.Count).ToString();
                        if (obj.GetCount() < 0)
                        {
                            obj.ComCount = "0";
                        }
                    }
                    newList.Add(obj); 
                }
                if (allComMap.ContainsKey(bomName))
                {
                    allComMap[bomName] = newList;
                }
                CSVBomManager.SaveBomToFile(bomName, newList);
            }
            catch (Exception ex)
            {

            }
            return true;
        }
        public static string AutoAddBomList(string bomName, List<ComponetInfo> comList)
        {
            string newBomName = bomName;
            //自动新增元器件库  
            if (CSVBomManager.BomNameIsExists(bomName))
            {
                bomName = bomName + DateTime.Now.ToString("-MM-dd-HH-mm-ss");
                if (CSVBomManager.BomNameIsExists(bomName))
                {
                    for (int i = 1; i <= 100; i++)
                    {
                        string testName = bomName + "-" + i;
                        if (!CSVBomManager.BomNameIsExists(testName))
                        {
                            bomName = testName;
                            break;
                        }
                    }
                }
            }
            Dictionary<string, ComponetInfo> comMap = new Dictionary<string, ComponetInfo>();
            foreach (ComponetInfo obj in comList)
            {
                string key = obj.PN + "-" + obj.PositionNum;                
                if (comMap.ContainsKey(key))
                {
                    continue;
                }
                //obj.TagNo = "";
                comMap.Add(key, obj);
            }
            List<ComponetInfo> list = new List<ComponetInfo>(comMap.Values);
            for (int i = 0; i < list.Count; i++)
            {
                list[i].Id = i + 1;
                list[i].SaveImage(bomName, null, list[i].ImgBase64Data);
            }
            CSVBomManager.AddBom(bomName, list);

            return bomName;
        }


        public static List<List<string>> ReadFile(string filePath, out List<string> titleList)
        {
            titleList = new List<string>();
            List<List<string>> resultMap = new List<List<string>>();

            string[] lines = ReadCSVFile(filePath);
            int index = 0;
            foreach (var line in lines)
            {
                var newLine = line.Replace("\"", "");
                var array = newLine.Split(Spilt_Char);
                array = FromCsvLine(line);
                if (index == 0)
                {
                    titleList.AddRange(array);
                }
                else
                {
                    List<string> lineList = new List<string>();
                    lineList.AddRange(array);
                    resultMap.Add(lineList);
                }
                index++;
            }
            return resultMap;
        }
    }
}