using log4net;
using OnlineStore.Common;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reflection;
using System.Text;
 
namespace OnlineStore.LoadCSVLibrary
{
    public class DeviceConfig
    {
        public static  Dictionary<int, Dictionary<string, ConfigIO>> SubDIList { get; set; }
        public static Dictionary<int, Dictionary<string, ConfigIO>> SubDOList { get; set; }
        //public static readonly ILog LOGGER = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        public static  Dictionary<string, string> ProIOIpMap = null;
        public static Dictionary<string, string> ProRFIpMap = null;
        public const string IOIP_Str = "PRO_AOI_IP";
        public const string RFIP_Str = "PRO_RFIP";
        /// <summary>
        /// ID
        /// </summary>
        public int Id { get; set; }
        /// <summary>
        /// 编号，与服务器通信的唯一标识
        /// </summary>
        public string CID { get; set; }
        /// <summary>
        /// 设备类型
        /// </summary>
        public string DType { get; set; }
        /// <summary>
        /// 配置文件路径
        /// </summary>
        public string ConfigFilePath { get; set; }

        /// <summary>
        /// 输入IO配置
        /// 手动料仓输入Io列表，key=对应的坐标位置的positionNum
        /// </summary>
        public Dictionary<String, ConfigIO> DIList { get; set; }
        /// <summary>
        /// 输出IO配置
        /// 手动料仓输出Io列表，key=对应的坐标位置的positionNum
        /// </summary>
        public Dictionary<String, ConfigIO> DOList { get; set; }
         
        /// <summary>
        /// 料仓所有用到的IO卡名称
        /// </summary>
        public List<string> IOIPList { get; set; }
    
        /// <summary>
        /// 必须拥有的DI列表
        /// </summary>
        protected List<string> MustHaveDIList { get; set; }
        /// <summary>
        /// 必须拥有的DO列表
        /// </summary>
        protected List<string> MustHaveDOList { get; set; }

        protected virtual void initMustHavePro()
        {
            MustHaveDIList = new List<string>();
            MustHaveDOList = new List<string>();
        }
        public DeviceConfig()
        {
            initMustHavePro();
        }

        public DeviceConfig(int id, string cid, string type, string filepath)
        {
            initMustHavePro();
            MustHaveDIList = new List<string>();
            MustHaveDOList = new List<string>();
            this.Id = id;
            this.CID = cid;
            this.DType = type;
            this.ConfigFilePath = filepath;
        }
        private int LineSubType = 1000;
        public virtual void LoadConfig(List<ConfigBase> configList)
        {
            List<string> ioTypeList = IO_Type.GetTypeList();
           //ioTypeList = new List<string>();
            StringBuilder builder = new StringBuilder("\r\n");
            StringBuilder proBuilder = new StringBuilder("\r\n");
            DIList = new Dictionary<string, ConfigIO>();
            DOList = new Dictionary<string, ConfigIO>();
            //SubDIList = new Dictionary<int, Dictionary<string, ConfigIO>>();
            // SubDOList = new Dictionary<int, 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)
            {
                if (con.ProType == ConfigItemType.AXIS || con.ProType == ConfigItemType.PRO||con.ProType==ConfigItemType.CLAW)
                {
                    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.CLAW)
                            {
                                //如果属性存在
                                prop.SetValue(this, Convert.ChangeType(con, prop.PropertyType), null);//赋值****在这里需要考虑类型问题
                                ConfigClampJaw jaw = (ConfigClampJaw)con;
                                if (!XLRStore_Config.ClampJawMap.ContainsKey(jaw.SubType))
                                { 
                                    XLRStore_Config.ClampJawMap.Add(jaw.SubType, jaw);
                                }
                            }
                            else if (con.ProType == ConfigItemType.PRO)
                            {
                                prop.SetValue(this, Convert.ChangeType(con.ProValue, prop.PropertyType), null);//赋值 
                            }
                        }
                        else
                        {
                            LogUtil.error("配置文件：" + this.ConfigFilePath + "，属性名=" + con.ProName + "的属性未找到匹配字段！");
                        }
                    }
                    else if (!ProIOIpMap.ContainsKey(con.ProName) && con.ProName.ToUpper().Contains(IOIP_Str.ToUpper()))
                    {
                        ProIOIpMap.Add(con.ProName, con.ProValue);
                    }
                    else if (!ProRFIpMap.ContainsKey(con.ProName) && con.ProName.ToUpper().Contains(RFIP_Str.ToUpper()))
                    {
                        ProRFIpMap.Add(con.ProName, con.ProValue);
                    }
                    else
                    {
                        AddProBuffer(con, proBuilder);
                        LogUtil.error("配置文件：" + this.ConfigFilePath + "，属性名=" + con.ProName + "的属性未找到匹配字段！");
                    }
                    //AddProBuffer(con, proBuilder);
                }

                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 (io.SubType >= 0)
                    { 
                            if (DIList.ContainsKey(io.ProName))
                            {
                                //LogUtil.error("配置DI：[" + io.ToString() + "] ProName重复 ");
                            }
                            else
                            {
                                this.DIList.Add(io.ProName, io);
                            } 

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

                    if (!ioTypeList.Contains(con.ProName))
                    {
                        ioTypeList.Add(con.ProName);
                        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 (io.SubType >= 0)
                    {
                        string newType = io.ProName.Replace("SW1_", "SW_").Replace("SW2_", "SW_").Replace("SW3_", "SW_").Replace("SW4_", "SW_");
                        if (DOList.ContainsKey(newType))
                        {
                            LogUtil.error("配置DO：[" + io.ToString() + "] ProName重复 ");
                        }
                        else
                        {
                            this.DOList.Add(newType, io);
                        }

                    }
                    else
                    {
                        if (DOList.ContainsKey(io.ProName))
                        {
                            LogUtil.error("配置DO：[" + io.ToString() + "] ProName重复 ");
                        }
                        else
                        {
                            this.DOList.Add(con.ProName, io);
                        }
                    }
                    if (io.DeviceName.Equals("HC"))
                    {
                        if (!SubDOList.ContainsKey(io.SubType))
                        {
                            SubDOList.Add(io.SubType, new Dictionary<string, ConfigIO>());
                        }
                        if (SubDOList[io.SubType].ContainsKey(io.ProName))
                        {
                            LogUtil.error("配置DO：[" + io.ToString() + "] ProName重复 ");
                        }
                        else
                        {
                            SubDOList[io.SubType].Add(io.ProName, io);
                        }
                    }

                    if (!ioTypeList.Contains(con.ProName))
                    {
                        ioTypeList.Add(con.ProName);
                        AddBuffer(con, builder);
                    }
                }
            }
            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
                            {
                                try
                                {
                                    if (prop.PropertyType.Equals(typeof(int))||prop.PropertyType.Equals(typeof(Int32)))
                                    {
                                        prop.SetValue(this, Convert.ChangeType(0, prop.PropertyType), null);//赋值****在这里需要考虑类型问题
                                    }
                                    else if (prop.PropertyType.Equals(typeof(bool)))
                                    {
                                        prop.SetValue(this, Convert.ChangeType(false , prop.PropertyType), null);//赋值****在这里需要考虑类型问题
                                    }
                                    else
                                    {
                                        prop.SetValue(this, Convert.ChangeType("", prop.PropertyType), null);//赋值****在这里需要考虑类型问题
                                    }
                                }catch(Exception ex)
                                {
                                    LogUtil.error("LoadConfig赋值出错：" + this.ToString() + "的属性" + str + "必须配置值！" + ex.ToString()); 
                                    throw ex;
                                }
                            }
                        }
                    }
                }

                //DI检测
                foreach (string di in MustHaveDIList)
                {
                    if (!DIList.ContainsKey(di))
                    {
                        throw new CVSFieldNotMatchingExection(  "【"+ ConfigFilePath + "】的DI属性" + di + "必须配置值！");
                    }
                }

                //DO检测
                foreach (string io in MustHaveDOList)
                {
                    if (!this.DOList.ContainsKey(io))
                    {
                        throw new CVSFieldNotMatchingExection("【" + ConfigFilePath + "】的DO属性" + io + "必须配置值！");
                    }
                }

            }
        }
        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(DeviceConfig.SubDIList.ContainsKey(0))
            {
                foreach (var item in DeviceConfig.SubDIList[0])
                {
                    diList.Add(item.Key,item.Value);
                }
            }
            if (DeviceConfig.SubDOList.ContainsKey(0))
            {
                foreach (var item in DeviceConfig.SubDOList[0])
                {
                    doList.Add(item.Key, item.Value);
                }
            }
            if (DeviceConfig.SubDIList.ContainsKey(subType))
            {
                foreach (var item in DeviceConfig.SubDIList[subType])
                {
                    diList.Add(item.Key, item.Value);
                }
            }
            if (DeviceConfig.SubDOList.ContainsKey(subType))
            {
                foreach (var item in DeviceConfig.SubDOList[subType])
                {
                    doList.Add(item.Key, item.Value);
                }
            }
            ConfigIO nsc = null;
            foreach (string key in diList.Keys)
            {
                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);
                }
            }
        }
        public ConfigIO getWaitIO(string ioType)
        {
            if (DIList.ContainsKey(ioType))
            {
                return DIList[ioType];
            }
            else if (DOList.ContainsKey(ioType))
            {
                return DOList[ioType];
            }
            return null;
        }
        public string GetDisplayName(string ioType)
        {
            ConfigIO io = getWaitIO(ioType);
            if (io == null)
            {
                return ioType;
            }
            return io.DisplayStr;
        }
    } 
    public class DeviceType
    { 
        public static string Store = "Store";
        
        public static string BoxEquip = "BoxEquip";
     
        public static string InputEquip = "InputEquip"; 
        

    }
   
}