using Bro.Common.Helper;
using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using static Bro.Common.Helper.EnumHelper;

namespace Bro.Common.Model
{
    public class IOItem : IComplexDisplay, IEqualityComparer
    {
        /// <summary>
        /// IO点编号
        /// </summary>
        [Category("IO配置")]
        [Description("IO点编号")]
        public virtual int IONum { get; set; }

        /// <summary>
        /// IO点的值
        /// </summary>
        [Category("IO配置")]
        [Description("IO状态")]
        [TypeConverter(typeof(EnumDescriptionConverter<IOValue>))]
        public virtual IOValue Value { get; set; }

        /// <summary>
        /// IO点是in还是out
        /// </summary>   
        [Category("IO配置")]
        [Description("IO类型")]
        public virtual IOType IOType { get; set; }

        public new bool Equals(object x, object y)
        {
            if (x is IOItem a && y is IOItem b)
            {
                return a.IOType == b.IOType && a.IONum == b.IONum;
            }

            return false;
        }

        public virtual string GetDisplayText()
        {
            return $"{IOType.GetEnumDescription()}-{IONum}-{Value.GetEnumDescription()}";
        }

        public int GetHashCode(object obj)
        {
            return obj.GetHashCode();
        }
    }

    public class IODefinition : IOItem
    {
        [Category("IO配置")]
        [Description("IO预定义")]
        [TypeConverter(typeof(EnumDescriptionConverter<IOPrestatement>))]
        public IOPrestatement IOPreStatement { get; set; } = IOPrestatement.Customized;

        [Category("IO配置")]
        [Description("IO用途描述")]
        public string IODesc { get; set; }

        [Category("IO配置")]
        [Description("备注说明")]
        public string Remark { get; set; }

        [Browsable(false)]
        [JsonIgnore]
        public override IOValue Value { get; set; }

        public override string GetDisplayText()
        {
            return $"{(IOPreStatement == IOPrestatement.Customized ? IODesc : IOPreStatement.GetEnumDescription())} {IOType.GetEnumDescription()} {IONum}";
        }
    }

    public class IORefrenceItem : IComplexDisplay
    {
        [Category("IO操作配置")]
        [Description("需要操作的IO")]
        [TypeConverter(typeof(IORefrenceItemSourceConverter))]
        public IODefinition IOItem { get; set; } = new IODefinition();

        [Category("IO操作配置")]
        [Description("需要操作的IO的状态")]
        public IOValue CheckValue
        {
            get => IOItem.Value;
            set => IOItem.Value = value;
        }

        [Browsable(false)]
        [JsonIgnore]
        public List<IODefinition> IOItemSource { get; set; } = new List<IODefinition>();

        public string GetDisplayText()
        {
            return IOItem.IODesc + "-" + CheckValue.GetEnumDescription();
        }
    }

    public class IORefrenceItemSourceConverter : TypeConverter
    {
        Dictionary<IODefinition, string> itemDict = new Dictionary<IODefinition, string>();
        public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
        {
            itemDict.Clear();
            if (context.Instance is IORefrenceItem item)
            {
                item.IOItemSource.ForEach(i =>
                {
                    IODefinition temp = new IODefinition();
                    temp.DataFrom(i);
                    itemDict[temp] = (string.IsNullOrWhiteSpace(i.IODesc) ? i.IOPreStatement.GetEnumDescription() : i.IODesc) + "|" + i.IOType.GetEnumDescription() + "|" + i.IONum;
                });

                return new StandardValuesCollection(itemDict.Keys);
            }

            return base.GetStandardValues(context);
        }
        public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
        {
            return true;
        }

        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
        {
            return true;
        }

        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            if (sourceType == typeof(String))
                return true;

            return base.CanConvertFrom(context, sourceType);
        }

        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            return base.CanConvertTo(context, destinationType);
        }

        public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues)
        {
            return base.CreateInstance(context, propertyValues);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="context"></param>
        /// <param name="culture"></param>
        /// <param name="value">string</param>
        /// <returns></returns>
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            var s = value.ToString().Split(new char[] { '|' });

            if (s.Length == 3)
            {
                foreach (KeyValuePair<IODefinition, string> pair in itemDict)
                {
                    if (pair.Value == value.ToString())
                    {
                        return pair.Key;
                    }
                }

                IODefinition item = new IODefinition();
                item.IODesc = s[0];
                item.IOType = (IOType)Enum.Parse(typeof(IOType), s[1]);
                item.IONum = int.Parse(s[2]);
                return item;
            }

            return base.ConvertFrom(context, culture, value);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="context"></param>
        /// <param name="culture"></param>
        /// <param name="value">IOItem</param>
        /// <param name="destinationType"></param>
        /// <returns></returns>
        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            if (value is IODefinition item)
            {
                foreach (KeyValuePair<IODefinition, string> pair in itemDict)
                {
                    if (pair.Key.IOType == item.IOType && pair.Key.IONum == item.IONum)
                    {
                        return pair.Value;
                    }
                }

                return item.IODesc + "-" + item.IOType.GetEnumDescription() + "-" + item.IONum;
            }

            return base.ConvertTo(context, culture, value, destinationType);
        }
    }
}