using DevExpress.Utils.Extensions;
using System.Collections.Generic;
using System.Linq;

namespace IStation.DataProvider
{
    /// <summary>
    /// 信号类型 数据生成器
    /// </summary>
    public class SignalTypeGenerator
    {
        /// <summary>
        /// 生成
        /// </summary>
        public static bool Creater()
        {
            var group流量 = BuildGroup("流量");
            var type瞬时流量 = BuildType(group流量, "瞬时流量", Unit.eUnitType.流量, ((int)Unit.eUnitQ.M3H).ToString());
            var type累积流量 = BuildType(group流量, "累积流量", Unit.eUnitType.体积, ((int)Unit.eUnitVol.M3).ToString(), false);


            var group压力 = BuildGroup("压力");
            var type压力 = BuildType(group压力, "压力", Unit.eUnitType.压力, ((int)Unit.eUnitPR.MPa).ToString());
            var type水位 = BuildType(group压力, "水位", Unit.eUnitType.长度, ((int)Unit.eUnitL.m).ToString());
            var type扬程 = BuildType(group压力, "扬程", Unit.eUnitType.扬程, ((int)Unit.eUnitH.M).ToString());

            var group功率 = BuildGroup("功率");
            var type视在功率 = BuildType(group功率, "视在功率", Unit.eUnitType.视在功率, ((int)Unit.eUnitPs.kVA).ToString());
            var type有功功率 = BuildType(group功率, "有功功率", Unit.eUnitType.有功功率, ((int)Unit.eUnitP.KW).ToString());
            var type无功功率 = BuildType(group功率, "无功功率", Unit.eUnitType.无功功率, ((int)Unit.eUnitPQ.kVar).ToString());



            var group频率 = BuildGroup("频率");
            var type频率 = BuildType(group频率, "频率", Unit.eUnitType.频率, ((int)Unit.eUnitHZ.hz).ToString());
            var type转速 = BuildType(group频率, "转速", Unit.eUnitType.转速, ((int)Unit.eUnitN.r_min).ToString());


            var group电度 = BuildGroup("电度");
            var type有功电度 = BuildType(group电度, "有功电度", Unit.eUnitType.有功电度, ((int)Unit.eUnitEleDegree.kwh).ToString(), false);
            var type无功电度 = BuildType(group电度, "无功电度", Unit.eUnitType.无功电度, ((int)Unit.eUnitEleDegreeQ.kVarh).ToString());


            var group设备 = BuildGroup("设备");
            var type运行状态 = BuildType(group设备, "运行状态", new Dictionary<int, string>
            {
                { -2, "未知" },
                { -1, "故障" },
                { 0, "停机" },
                { 1, "开机" },
                { 2, "工频" },
                { 3, "变频" }
            });

            var type运行时间 = BuildType(group设备, "运行时间", Unit.eUnitType.累积时间, ((int)Unit.eUnitSumTime.Second).ToString(), false);
            var type开机次数 = BuildType(group设备, "开机次数", Unit.eUnitType.自定义, "次", false);
            var type效率 = BuildType(group设备, "效率", Unit.eUnitType.效率, ((int)Unit.eUnitE.Percent).ToString());
            var type千吨能耗 = BuildType(group设备, "千吨能耗", Unit.eUnitType.千吨能耗, ((int)Unit.eUnitWP.kWh_km_3).ToString());
            var type单位能耗 = BuildType(group设备, "单位能耗", Unit.eUnitType.单位能耗, ((int)Unit.eUnitUWP.kWh_km_3_m).ToString());


            var group电 = BuildGroup("电");
            var type电流 = BuildType(group电, "电流", Unit.eUnitType.电流, ((int)Unit.eUnitCurrent.A).ToString());
            var type电压 = BuildType(group电, "电压", Unit.eUnitType.电压, ((int)Unit.eUnitVoltage.V).ToString());
            var type电导率 = BuildType(group电, "电导率", Unit.eUnitType.电导率, ((int)Unit.eUnitCond.Sm).ToString());


            var group环境 = BuildGroup("环境");
            var type温度 = BuildType(group环境, "温度", Unit.eUnitType.温度, ((int)Unit.eUnitTP.C).ToString());
            var type浊度 = BuildType(group环境, "浊度", Unit.eUnitType.浊度, ((int)Unit.eUnitTU.NTU).ToString());
            var type余氯 = BuildType(group环境, "余氯", Unit.eUnitType.浓度, ((int)Unit.eUnitCO.mgL).ToString());
            var type湿度 = BuildType(group环境, "湿度", Unit.eUnitType.湿度, ((int)Unit.eUnitHM.Rh).ToString());
            var typePH = BuildType(group环境, "PH", Unit.eUnitType.自定义, "");
            var type溶解氧 = BuildType(group环境, "溶解氧", Unit.eUnitType.浓度, ((int)Unit.eUnitCO.mgL).ToString());
            var type音量 = BuildType(group环境, "音量", Unit.eUnitType.音量, ((int)Unit.eUnitSou.db).ToString());
            var type噪音 = BuildType(group环境, "噪音", Unit.eUnitType.音量, ((int)Unit.eUnitSou.db).ToString());


            var group阀门 = BuildGroup("阀门");
            var type阀门状态 = BuildType(group阀门, "阀门状态", new Dictionary<int, string>
            {
                { 0, "关" },
                { 1, "开" },
                { 2, "中间" }
            });
            var type阀门开度 = BuildType(group阀门, "阀门开度", Unit.eUnitType.自定义, "");


            var signalTypeGroups = new List<Model.SignalTypeGroup>()
            {
                group流量,
                group压力,
                group功率,
                group频率,
                group电度,
                group设备,
                group电 ,
                group环境,
                group阀门,
            };

            var index = 1;
            signalTypeGroups.ForEach(x =>
            {
                x.SortCode = index++;
            });

            var signalTypes = new List<Model.SignalType>()
            {

                type瞬时流量,
                type累积流量,
                type压力,
                type水位,
                type扬程,
                type视在功率,
                type有功功率,
                type无功功率,
                type频率,
                type转速,
                type有功电度,
                type无功电度,
                type运行状态,
                type运行时间,
                type开机次数,
                type效率,
                type千吨能耗,
                type单位能耗,
                type电流,
                type电压,
                type电导率,
                type温度,
                type浊度,
                type余氯,
                type湿度,
                typePH,
                type溶解氧,
                type音量,
                type噪音,
                type阀门状态,
                type阀门开度,
            };

            var groups = signalTypes.GroupBy(x => x.GroupID);
            groups.ForEach(x =>
            {
                var i = 1;
                x.ForEach(t =>
                {
                    t.SortCode = i++;
                });
            });


            if (!new BLL.SignalTypeGroup().Covers(signalTypeGroups))
            {
                return false;
            };
            if (!new BLL.SignalType().Covers(signalTypes))
            {
                return false;
            }

            return true;
        }

        private static Model.SignalTypeGroup BuildGroup(string name)
        {
            var model = new Model.SignalTypeGroup();
            model.ID = SnowflakeIdHelper.NextId();
            model.Name = name;
            return model;
        }

        private static Model.SignalType BuildType(Model.SignalTypeGroup group, string identifier, Unit.eUnitType unitType, string unitValue, bool instant = true)
        {
            var model = new Model.SignalType();
            model.GroupID = group.ID;
            model.ID = SnowflakeIdHelper.NextId();
            model.Name = identifier;
            model.Identifier = identifier;
            model.FormatType = Model.eFormatType.Numeric;
            var paras = new Model.SignalType.NumericFormatParas()
            {
                UnitType = unitType,
                UnitValue = unitValue,
                DecimalPlaces = 1,
            };
            model.FormatParas = JsonHelper.Object2Json(paras);
            model.MeasureType = instant ? Model.eMeasureType.Instant : Model.eMeasureType.Accumulate;
            return model;
        }

        private static Model.SignalType BuildType(Model.SignalTypeGroup group, string identifier, Dictionary<int, string> dict, bool instant = true)
        {
            var model = new Model.SignalType();
            model.GroupID = group.ID;
            model.ID = SnowflakeIdHelper.NextId();
            model.Name = identifier;
            model.Identifier = identifier;
            model.FormatType = Model.eFormatType.Enum;

            if (dict != null && dict.Any())
            {
                var formatParas = new Model.SignalType.EnumFormatParas();
                formatParas.Items = new List<Model.SignalType.EnumFormatItem>();
                foreach (var dictItem in dict)
                {
                    var item = new Model.SignalType.EnumFormatItem();
                    item.Name = dictItem.Value;
                    item.Value = dictItem.Key;
                    formatParas.Items.Add(item);
                }
                model.FormatParas = formatParas.ToJson();
            }


            JsonHelper.Object2Json(dict);
            model.MeasureType = instant ? Model.eMeasureType.Instant : Model.eMeasureType.Accumulate;
            return model;
        }


    }
}