using log4net;
using OnlineStore.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;

namespace OnlineStore.LoadCSVLibrary
{
    public class BaseConfig
    {
        private bool codeAutoLog = false ;
        public static Dictionary<int, Dictionary<string, ConfigIO>> SubDIList { get; set; }
        public static Dictionary<int, Dictionary<string, ConfigIO>> SubDOList { get; set; }
        public static Dictionary<string, string> ProIOIpMap = null;
        public const string IOIP_Str = "PRO_AIO_IP";
 
        public int Id { get; set; }
        public string CID { get; set; }
        /// <summary>
        /// 设备类型
        /// </summary>
        public string DType { get; set; }
 
        public string ConfigFilePath { get; set; }

        public Dictionary<String, ConfigIO> DIList { get; set; }

        public Dictionary<String, ConfigIO> DOList { get; set; }
         
        public List<string> IOIPList { get; set; }


        public BaseConfig()
        {
        }

        public BaseConfig(int id, string CID, string type, string filepath)
        {
            this.CID = CID;

            this.Id = id;
            this.DType = type;
            this.ConfigFilePath = filepath; 
        }
        public virtual void LoadConfig(List<ConfigBase> configList)
        {
            if (SubDIList == null)
            {
                SubDIList = new Dictionary<int, Dictionary<string, ConfigIO>>();
            }
            if (SubDOList == null)
            {
                SubDOList = new Dictionary<int, Dictionary<string, ConfigIO>>();
            }
            List<string> ioTypeList = IO_Type.GetTypeList();

            StringBuilder builder = new StringBuilder("\r\n");
            StringBuilder proBuilder = new StringBuilder("\r\n");
            DIList = new Dictionary<string, ConfigIO>();
            DOList = new Dictionary<string, ConfigIO>();

            IOIPList = new List<string>();
            //取得属性集合
            PropertyInfo[] props = GetType().GetProperties();
            Dictionary<string, string> proMap = CSVReaderBase.getConfigProAttributeMap(GetType());

            List<string> checkProList = new List<string>(proMap.Keys);//用来检测attribute属性都应该要配置值
            foreach (ConfigBase con in configList)
            {
                try
                {
                    if (con.ProType == ConfigItemType.AXIS || con.ProType == ConfigItemType.PRO)
                    {
                        if (proMap.ContainsKey(con.ProName))
                        {
                            string proName = proMap[con.ProName];
                            checkProList.Remove(con.ProName);
                            PropertyInfo prop = props.First(c => c.Name == proName);//获取同名属性
                            if (prop != null)
                            {
                                if (con.ProType == ConfigItemType.AXIS)
                                {
                                    //如果属性存在
                                    prop.SetValue(this, Convert.ChangeType(con, prop.PropertyType), null);//赋值****在这里需要考虑类型问题
                                    ConfigMoveAxis axis = (ConfigMoveAxis)con;

                                }
                                else if (con.ProType == ConfigItemType.PRO)
                                {
                                    prop.SetValue(this, Convert.ChangeType(con.ProValue, prop.PropertyType), null);//赋值 
                                }
                            }
                            else
                            {
                                LogUtil.error("配置文件：" + this.ConfigFilePath + "，属性名=" + con.ProName + "的属性未找到匹配字段！");
                            }
                        }
                        if (!ProIOIpMap.ContainsKey(con.ProName) && con.ProName.ToUpper().Contains(IOIP_Str.ToUpper()))
                        {
                            ProIOIpMap.Add(con.ProName, con.ProValue);
                        }
                        else if (codeAutoLog || (!proMap.ContainsKey(con.ProName)))
                        {
                            AddProBuffer(con, proBuilder);
                            LogUtil.error("配置文件：" + this.ConfigFilePath + "，属性名=" + con.ProName + "的属性未找到匹配字段！");
                        }
                    }

                    else if (con.ProType == ConfigItemType.DI)
                    {
                        ConfigIO io = (ConfigIO)con;
                        if (!IOIPList.Contains(io.IO_IP) && io.GetIOAddr() >= 0)
                        {
                            IOIPList.Add(io.IO_IP);
                        }
                        if (DIList.ContainsKey(io.ProName))
                        {
                            LogUtil.debug("配置DI：[" + io.ToString() + "] ProName重复 ");
                        }
                        else
                        {
                            this.DIList.Add(con.ProName, io);
                        }


                        if (!SubDIList.ContainsKey(io.SubType))
                        {
                            SubDIList.Add(io.SubType, new Dictionary<string, ConfigIO>());
                        }
                        if (SubDIList[io.SubType].ContainsKey(io.ProName))
                        {
                            LogUtil.debug("配置DI：[" + io.ToString() + "] ProName重复 ");
                        }
                        else
                        {
                            SubDIList[io.SubType].Add(io.ProName, io);
                        }

                        if (!ioTypeList.Contains(con.ProName) || codeAutoLog)
                        {
                            AddBuffer(con, builder);
                        }

                    }
                    else if (con.ProType == ConfigItemType.DO)
                    {
                        ConfigIO io = (ConfigIO)con;
                        if (!IOIPList.Contains(io.IO_IP) && io.GetIOAddr() >= 0)
                        {
                            IOIPList.Add(io.IO_IP);
                        }
                        if (DOList.ContainsKey(io.ProName))
                        {
                            LogUtil.debug("配置DO：[" + io.ToString() + "] ProName重复 ");
                        }
                        else
                        {
                            this.DOList.Add(con.ProName, io);
                        }

                        if (!SubDOList.ContainsKey(io.SubType))
                        {
                            SubDOList.Add(io.SubType, new Dictionary<string, ConfigIO>());
                        }
                        if (SubDOList[io.SubType].ContainsKey(io.ProName))
                        {
                            LogUtil.debug("配置DO：[" + io.ToString() + "] ProName重复 ");
                        }
                        else
                        {
                            SubDOList[io.SubType].Add(io.ProName, io);
                        }
                        if (!ioTypeList.Contains(con.ProName) || codeAutoLog)
                        {
                            AddBuffer(con, builder);
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error("解析配置【" + con.ConfigStr + "】出错：" + ex.ToString());
                }
            }
            if (String.IsNullOrEmpty(proBuilder.ToString()).Equals(false) && proBuilder.ToString().Equals("\r\n").Equals(false))
            {
                LogUtil.error(proBuilder.ToString());
            }
            if (String.IsNullOrEmpty(builder.ToString()).Equals(false) && builder.ToString().Equals("\r\n").Equals(false))
            {
                LogUtil.error(builder.ToString());
            }
            if (checkProList.Count >= 0)
            {
                //常规属性检测
                foreach (string str in checkProList)
                {
                    PropertyInfo prop = props.First(c => c.Name == str);//获取同名属性
                                                                        //判断是否必须要配置
                    object[] array = prop.GetCustomAttributes(false);
                    if (array.Length > 0)
                    {
                        ConfigProAttribute att = (ConfigProAttribute)array[0];
                        if (att != null)
                        {
                            if (att.IsMust)
                            {
                                throw new CVSFieldNotMatchingExection(this.ToString() + "的属性【" + str + "】必须配置值！");
                            }
                            else
                            {
                                if (prop.PropertyType.Equals(typeof(int)))
                                {
                                    prop.SetValue(this, Convert.ChangeType(0, prop.PropertyType), null);//赋值****在这里需要考虑类型问题
                                }
                                else
                                {
                                    prop.SetValue(this, Convert.ChangeType("", prop.PropertyType), null);//赋值****在这里需要考虑类型问题
                                }
                            }
                        }
                    }
                }
            }
        }
        private void AddProBuffer(ConfigBase con, StringBuilder builder)
        {
            builder.Append(" /// <summary>\r\n");
            builder.Append(" ///  " + con.ConfigStr + "\r\n");
            builder.Append(" /// </summary>\r\n");
            builder.Append(" [ConfigProAttribute(\"" + con.ProName + "\")]\r\n");
            builder.Append(" public int " + con.ProName + "  { get; set; }\r\n");
        }
        private void AddBuffer(ConfigBase con, StringBuilder builder)
        {
            builder.Append(" /// <summary>\r\n");
            builder.Append(" ///  " + con.ConfigStr + "\r\n");
            builder.Append(" /// </summary>\r\n");
            builder.Append(" public static string " + con.ProName + "=\"" + con.ProName + "\";\r\n");
        }

        public void SetIO(int subType)
        {
            Dictionary<string, ConfigIO> doList = new Dictionary<string, ConfigIO>();
            Dictionary<string, ConfigIO> diList = new Dictionary<string, ConfigIO>();

            if (BaseConfig.SubDIList.ContainsKey(subType))
            {
                diList = BaseConfig.SubDIList[subType];
            }
            if (BaseConfig.SubDOList.ContainsKey(subType))
            {
                doList = BaseConfig.SubDOList[subType];
            }
            ConfigIO nsc = null;
            foreach (string key in diList.Keys)
            {
                //if (key.Equals(IO_Type.NextStopCheck))
                //{
                //    nsc = diList[key];
                //    continue;
                //}
                DIList.Add(key, diList[key]);
                if (!IOIPList.Contains(diList[key].IO_IP))
                {
                    IOIPList.Add(diList[key].IO_IP);
                }
            }
            foreach (string key in doList.Keys)
            {
                DOList.Add(key, doList[key]);

                if (!IOIPList.Contains(doList[key].IO_IP))
                {
                    IOIPList.Add(doList[key].IO_IP);
                }
            }

            //if (nsc!=null)
            //{ 
            //    DIList.Add(IO_Type.NextStopCheck, nsc);
            //}
        }
        public ConfigIO getWaitIO(string ioType)
        {
            if (DIList.ContainsKey(ioType))
            {
                return DIList[ioType];
            }
            else if (DOList.ContainsKey(ioType))
            {
                return DOList[ioType];
            }
            return null;
        }

    }
    public class DeviceType
    {
        /// <summary>
        /// 流水线线体
        /// </summary>
        public static string Line = "Line";

        public static string XRay = "MoveEquip";

        public static string OutputDevice = "OutputDevice";

        public static string InputDevice = "InputDevice";


    }
}