using Microsoft.Extensions.Logging.Abstractions;

namespace Yw.Hydro
{
    /// <summary>
    /// 解析辅助类
    /// </summary>
    public static class ParseHelper
    {
        /// <summary>
        /// 
        /// </summary>
        public static Network ToNetwork(this Yw.Model.HydroModelInfo model)
        {
            if (model == null)
            {
                return default;
            }
            var netWork = new Network();

            #region 节点

            //水库
            if (model.Reservoirs != null && model.Reservoirs.Count > 0)
            {
                foreach (var reservoir in model.Reservoirs)
                {
                    var reservoirModel = new Reservoir();
                    reservoirModel.Id = reservoir.Code;
                    reservoirModel.Catalog = Yw.EPAnet.Catalog.Reservoir;
                    reservoirModel.Name = reservoir.Name;
                    reservoirModel.Quality = 0;
                    reservoirModel.Position = new Position2d(reservoir.Position2d.X, reservoir.Position2d.Y);
                    reservoirModel.Head = reservoir.Head;
                    reservoirModel.HeadPattern = string.Empty;
                    netWork.Reservoirs.Add(reservoirModel);
                }
            }

            //水池
            if (model.Tanks != null && model.Tanks.Count > 0)
            {
                foreach (var tank in model.Tanks)
                {
                    var tankModel = new Tank();
                    tankModel.Id = tank.Code;
                    tankModel.Catalog = Yw.EPAnet.Catalog.Tank;
                    tankModel.Name = tank.Name;
                    tankModel.Quality = 0;
                    tankModel.Position = new Position2d(tank.Position2d.X, tank.Position2d.Y);
                    tankModel.PoolElev = tank.PoolElev;
                    tankModel.InitLevel = tank.InitLevel;
                    tankModel.MaxLevel = tank.MaxLevel;
                    tankModel.MinLevel = tank.MinLevel;
                    tankModel.Diameter = tank.DN;
                    tankModel.MinVol = tank.MinVol;
                    tankModel.VolCurve = tank.VolCurve;
                    tankModel.Overflow = tank.OverFlow;
                    netWork.Tanks.Add(tankModel);
                }
            }

            //水箱
            if (model.Waterboxs != null && model.Waterboxs.Count > 0)
            {
                foreach (var waterbox in model.Waterboxs)
                {
                    var waterboxModel = new Waterbox();
                    waterboxModel.Id = waterbox.Code;
                    waterboxModel.Catalog = Yw.EPAnet.Catalog.Waterbox;
                    waterboxModel.Name = waterbox.Name;
                    waterboxModel.Quality = 0;
                    waterboxModel.Position = new Position2d(waterbox.Position2d.X, waterbox.Position2d.Y);
                    waterboxModel.PoolElev = waterbox.PoolElev;
                    waterboxModel.InitLevel = waterbox.InitLevel;
                    waterboxModel.MaxLevel = waterbox.MaxLevel;
                    waterboxModel.MinLevel = waterbox.MinLevel;
                    waterboxModel.Diameter = waterbox.DN;
                    waterboxModel.MinVol = waterbox.MinVol;
                    waterboxModel.VolCurve = waterbox.VolCurve;
                    waterboxModel.Overflow = waterbox.OverFlow;
                    netWork.Waterboxs.Add(waterboxModel);
                }
            }

            //连接节点
            if (model.Junctions != null && model.Junctions.Count > 0)
            {
                foreach (var junction in model.Junctions)
                {
                    var junctionModel = new Junction();
                    junctionModel.Id = junction.Code;
                    junctionModel.Catalog = Yw.EPAnet.Catalog.Junction;
                    junctionModel.Name = junction.Name;
                    junctionModel.Quality = 0;
                    junctionModel.Position = new Position2d(junction.Position2d.X, junction.Position2d.Y);
                    junctionModel.Elev = junction.Elev;
                    junctionModel.MinorLoss = junction.MinorLoss;
                    junctionModel.Demand = 0;
                    junctionModel.DemandPattern = null;

                    netWork.Junctions.Add(junctionModel);
                }
            }

            //喷嘴
            if (model.Nozzles != null && model.Nozzles.Count > 0)
            {
                foreach (var nozzle in model.Nozzles)
                {
                    var nozzleModel = new Nozzle();
                    nozzleModel.Id = nozzle.Code;
                    nozzleModel.Catalog = Yw.EPAnet.Catalog.Nozzle;
                    nozzleModel.Name = nozzle.Name;
                    nozzleModel.Quality = 0;
                    nozzleModel.Position = new Position2d(nozzle.Position2d.X, nozzle.Position2d.Y);
                    nozzleModel.Elev = nozzle.Elev;
                    nozzleModel.MinorLoss = nozzle.MinorLoss;
                    nozzleModel.Demand = 0;
                    nozzleModel.DemandPattern = null;
                    nozzleModel.Coefficient = nozzle.Coefficient;
                    netWork.Nozzles.Add(nozzleModel);
                }
            }

            //冷却塔
            if (model.Coolings != null && model.Coolings.Count > 0)
            {
                foreach (var cooling in model.Coolings)
                {
                    var coolingModel = new Nozzle();
                    coolingModel.Id = cooling.Code;
                    coolingModel.Catalog = Yw.EPAnet.Catalog.Nozzle;
                    coolingModel.Name = cooling.Name;
                    coolingModel.Quality = 0;
                    coolingModel.Position = new Position2d(cooling.Position2d.X, cooling.Position2d.Y);
                    coolingModel.Elev = cooling.Elev;
                    coolingModel.MinorLoss = cooling.MinorLoss;
                    coolingModel.Demand = 0;
                    coolingModel.DemandPattern = null;
                    coolingModel.Coefficient = cooling.Coefficient;
                    netWork.Nozzles.Add(coolingModel);
                }
            }

            //消火栓
            if (model.Hydrants != null && model.Hydrants.Count > 0)
            {
                foreach (var hydrant in model.Hydrants)
                {
                    var hydrantModel = new Hydrant();
                    hydrantModel.Id = hydrant.Code;
                    hydrantModel.Catalog = Yw.EPAnet.Catalog.Hydrant;
                    hydrantModel.Name = hydrant.Name;
                    hydrantModel.Quality = 0;
                    hydrantModel.Position = new Position2d(hydrant.Position2d.X, hydrant.Position2d.Y);
                    hydrantModel.Elev = hydrant.Elev;
                    hydrantModel.MinorLoss = hydrant.MinorLoss;
                    hydrantModel.Demand = 0;
                    hydrantModel.DemandPattern = null;
                    hydrantModel.Coefficient = hydrant.Coefficient;
                    netWork.Hydrants.Add(hydrantModel);
                }
            }

            //闷头
            if (model.Bluntheads != null && model.Bluntheads.Count > 0)
            {
                foreach (var blunthead in model.Bluntheads)
                {
                    var bluntheadModel = new Blunthead();
                    bluntheadModel.Id = blunthead.Code;
                    bluntheadModel.Catalog = Yw.EPAnet.Catalog.Blunthead;
                    bluntheadModel.Name = blunthead.Name;
                    bluntheadModel.Quality = 0;
                    bluntheadModel.Position = new Position2d(blunthead.Position2d.X, blunthead.Position2d.Y);
                    bluntheadModel.Elev = blunthead.Elev;
                    bluntheadModel.MinorLoss = blunthead.MinorLoss;
                    bluntheadModel.Demand = 0;
                    bluntheadModel.DemandPattern = null;
                    netWork.Bluntheads.Add(bluntheadModel);
                }
            }

            //弯头
            if (model.Elbows != null && model.Elbows.Count > 0)
            {
                foreach (var elbow in model.Elbows)
                {
                    var elbowModel = new Elbow();
                    elbowModel.Id = elbow.Code;
                    elbowModel.Catalog = Yw.EPAnet.Catalog.Elbow;
                    elbowModel.Name = elbow.Name;
                    elbowModel.Quality = 0;
                    elbowModel.Position = new Position2d(elbow.Position2d.X, elbow.Position2d.Y);
                    elbowModel.Elev = elbow.Elev;
                    elbowModel.MinorLoss = elbow.MinorLoss;
                    elbowModel.Demand = 0;
                    elbowModel.DemandPattern = null;
                    elbowModel.ElbowType = elbow.ElbowType;
                    elbowModel.BendingAngle = elbow.BendingAngle;
                    netWork.Elbows.Add(elbowModel);
                }
            }

            //三通
            if (model.Threelinks != null && model.Threelinks.Count > 0)
            {
                foreach (var threelink in model.Threelinks)
                {
                    var threelinkModel = new Threelink();
                    threelinkModel.Id = threelink.Code;
                    threelinkModel.Catalog = Yw.EPAnet.Catalog.Threelink;
                    threelinkModel.Name = threelink.Name;
                    threelinkModel.Quality = 0;
                    threelinkModel.Position = new Position2d(threelink.Position2d.X, threelink.Position2d.Y);
                    threelinkModel.Elev = threelink.Elev;
                    threelinkModel.MinorLoss = threelink.MinorLoss;
                    threelinkModel.Demand = 0;
                    threelinkModel.DemandPattern = null;
                    threelinkModel.RunningThroughLoss = threelink.RunningThroughLoss;
                    threelinkModel.BranchThroughLoss = threelink.BranchThroughLoss;
                    netWork.Threelinks.Add(threelinkModel);
                }
            }

            //四通
            if (model.Fourlinks != null && model.Fourlinks.Count > 0)
            {
                foreach (var fourlink in model.Fourlinks)
                {
                    var fourlinkModel = new Fourlink();
                    fourlinkModel.Id = fourlink.Code;
                    fourlinkModel.Catalog = Yw.EPAnet.Catalog.Fourlink;
                    fourlinkModel.Name = fourlink.Name;
                    fourlinkModel.Quality = 0;
                    fourlinkModel.Position = new Position2d(fourlink.Position2d.X, fourlink.Position2d.Y);
                    fourlinkModel.Elev = fourlink.Elev;
                    fourlinkModel.MinorLoss = fourlink.MinorLoss;
                    fourlinkModel.Demand = fourlink.Demand;
                    fourlinkModel.DemandPattern = fourlink.DemandPattern;
                    netWork.Fourlinks.Add(fourlinkModel);
                }
            }

            //水表
            if (model.Meters != null && model.Meters.Count > 0)
            {
                foreach (var meter in model.Meters)
                {
                    var meterModel = new Meter();
                    meterModel.Id = meter.Code;
                    meterModel.Catalog = Yw.EPAnet.Catalog.Meter;
                    meterModel.Name = meter.Name;
                    meterModel.Quality = 0;
                    meterModel.Position = new Position2d(meter.Position2d.X, meter.Position2d.Y);
                    meterModel.Elev = meter.Elev;
                    meterModel.MinorLoss = meter.MinorLoss;
                    meterModel.Demand = meter.Demand;
                    meterModel.DemandPattern = meter.DemandPattern;
                    netWork.Meters.Add(meterModel);
                }
            }

            //流量计
            if (model.Flowmeters != null && model.Flowmeters.Count > 0)
            {
                foreach (var flowmeter in model.Flowmeters)
                {
                    var flowmeterModel = new Flowmeter();
                    flowmeterModel.Id = flowmeter.Code;
                    flowmeterModel.Catalog = Yw.EPAnet.Catalog.Flowmeter;
                    flowmeterModel.Name = flowmeter.Name;
                    flowmeterModel.Quality = 0;
                    flowmeterModel.Position = new Position2d(flowmeter.Position2d.X, flowmeter.Position2d.Y);
                    flowmeterModel.Elev = flowmeter.Elev;
                    flowmeterModel.MinorLoss = flowmeter.MinorLoss;
                    flowmeterModel.Demand = flowmeter.Demand;
                    flowmeterModel.DemandPattern = flowmeter.DemandPattern;
                    netWork.Flowmeters.Add(flowmeterModel);
                }
            }

            //压力表
            if (model.Pressmeters != null && model.Pressmeters.Count > 0)
            {
                foreach (var pressmeter in model.Pressmeters)
                {
                    var pressmeterModel = new Pressmeter();
                    pressmeterModel.Id = pressmeter.Code;
                    pressmeterModel.Catalog = Yw.EPAnet.Catalog.Pressmeter;
                    pressmeterModel.Name = pressmeter.Name;
                    pressmeterModel.Quality = 0;
                    pressmeterModel.Position = new Position2d(pressmeter.Position2d.X, pressmeter.Position2d.Y);
                    pressmeterModel.Elev = pressmeter.Elev;
                    pressmeterModel.MinorLoss = pressmeter.MinorLoss;
                    pressmeterModel.Demand = pressmeter.Demand;
                    pressmeterModel.DemandPattern = pressmeter.DemandPattern;
                    netWork.Pressmeters.Add(pressmeterModel);
                }
            }

            #endregion

            #region 管段

            var allNodes = netWork.GetAllNodes();

            //管道
            if (model.Pipes != null && model.Pipes.Count > 0)
            {
                foreach (var pipe in model.Pipes)
                {
                    var pipeModel = new Pipe();
                    pipeModel.Id = pipe.Code;
                    pipeModel.Catalog = Yw.EPAnet.Catalog.Pipe;
                    pipeModel.Name = pipe.Name;
                    pipeModel.StartNode = allNodes.Find(x => x.Id == pipe.StartCode);
                    pipeModel.EndNode = allNodes.Find(x => x.Id == pipe.EndCode);
                    pipeModel.LinkStatus = Yw.Hydro.PipeStatus.Open;
                    pipeModel.Length = pipe.Length;
                    pipeModel.Diameter = pipe.Diameter;
                    pipeModel.Roughness = pipe.Roughness;
                    pipeModel.MinorLossCoeff = 0;
                    netWork.Pipes.Add(pipeModel);
                }
            }

            //过渡件
            if (model.Translations != null && model.Translations.Count > 0)
            {
                foreach (var translation in model.Translations)
                {
                    var translationModel = new Translation();
                    translationModel.Id = translation.Code;
                    translationModel.Catalog = Yw.EPAnet.Catalog.Translation;
                    translationModel.Name = translation.Name;
                    translationModel.StartNode = allNodes.Find(x => x.Id == translation.StartCode);
                    translationModel.EndNode = allNodes.Find(x => x.Id == translation.EndCode);
                    translationModel.LinkStatus = Yw.Hydro.LinkStatus.Open;
                    translationModel.Length = translation.Length;
                    if (translation.Length <= 0)
                    {
                        translation.Length = 0.1;
                    }
                    translationModel.Diameter = (translation.StartDiameter + translation.EndDiameter) / 2f;
                    translationModel.Roughness = translation.Roughness;
                    translationModel.MinorLossCoeff = translation.MinorLoss;
                    netWork.Translations.Add(translationModel);
                }
            }

            //水泵
            if (model.Pumps != null && model.Pumps.Count > 0)
            {
                foreach (var pump in model.Pumps)
                {
                    var pumpModel = new Pump();
                    pumpModel.Id = pump.Code;
                    pumpModel.Catalog = Yw.EPAnet.Catalog.Pump;
                    pumpModel.Name = pump.Name;
                    pumpModel.StartNode = allNodes.Find(x => x.Id == pump.StartCode);
                    pumpModel.EndNode = allNodes.Find(x => x.Id == pump.EndCode);
                    pumpModel.LinkStatus = pump.LinkStatus;
                    pumpModel.RatedP = pump.RatedP;
                    pumpModel.CurveQH = pump.CurveQH;
                    if (string.IsNullOrEmpty(pumpModel.CurveQH))
                    {
                        pumpModel.CurveQH = "PumpDefault";//使用network默认泵曲线
                    }
                    pumpModel.SpeedRatio = pump.SpeedRatio;
                    pumpModel.SpeedRatioPattern = pump.SpeedRatioPattern;
                    netWork.Pumps.Add(pumpModel);
                }
            }

            //阀门
            if (model.Valves != null && model.Valves.Count > 0)
            {
                foreach (var valve in model.Valves)
                {
                    //止回阀被当成管道处理
                    if (valve.ValveType == Yw.Hydro.ValveType.CV)
                    {
                        double length = 0.01;
                        if (double.TryParse(valve.ValveSetting, out double valveLength))
                        {
                            length = valveLength;
                            if (length <= 0)
                            {
                                length = 0.01;
                            }
                        }
                        var pipeModel = new Pipe();
                        pipeModel.Id = valve.Code;
                        pipeModel.Catalog = Yw.EPAnet.Catalog.Pipe;
                        pipeModel.Name = valve.Name;
                        pipeModel.StartNode = allNodes.Find(x => x.Id == valve.StartCode);
                        pipeModel.EndNode = allNodes.Find(x => x.Id == valve.EndCode);
                        pipeModel.LinkStatus = Yw.Hydro.PipeStatus.Open;
                        pipeModel.Length = length;
                        pipeModel.Diameter = valve.Diameter;
                        pipeModel.Roughness = valve.Roughness;
                        if (pipeModel.Roughness < 90)
                        {
                            pipeModel.Roughness = 110;
                        }
                        pipeModel.MinorLossCoeff = valve.MinorLoss;
                        netWork.Pipes.Add(pipeModel);
                    }
                    else
                    {
                        var valveModel = new Yw.EPAnet.Valve();
                        valveModel.Id = valve.Code;
                        valveModel.Catalog = Yw.EPAnet.Catalog.Valve;
                        valveModel.Name = valve.Name;
                        valveModel.StartNode = allNodes.Find(x => x.Id == valve.StartCode);
                        valveModel.EndNode = allNodes.Find(x => x.Id == valve.EndCode);
                        valveModel.LinkStatus = valve.LinkStatus;
                        valveModel.Diameter = valve.Diameter;
                        valveModel.MinorLoss = valve.MinorLoss;
                        valveModel.ValveType = valve.ValveType;
                        switch (valve.ValveType)
                        {
                            case Yw.Hydro.ValveType.PRV://减压阀
                                {
                                    valveModel.ValveSetting = valve.ValveSetting;
                                }
                                break;
                            case Yw.Hydro.ValveType.PSV://稳压阀
                                {
                                    valveModel.ValveSetting = valve.ValveSetting;
                                }
                                break;
                            case Yw.Hydro.ValveType.PBV://压力制动阀
                                {
                                    valveModel.ValveSetting = valve.ValveSetting;
                                }
                                break;
                            case Yw.Hydro.ValveType.FCV://流量控制阀
                                {
                                    valveModel.ValveSetting = valve.ValveSetting;
                                }
                                break;
                            case Yw.Hydro.ValveType.TCV://节流控制阀
                                {
                                    valveModel.ValveSetting = "0";
                                    var curveol = model.Curves?.Find(x => x.Code == valve.CurveOL);
                                    if (curveol != null)
                                    {
                                        var point2dList = curveol.CurveData.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
                                        var ptCurveOL = new Yw.Geometry.CubicSpline2d(point2dList);
                                        valveModel.ValveSetting = ptCurveOL.GetPointY(valve.OpeningDegree).ToString();
                                        if (valve.LinkStatus == Yw.Hydro.LinkStatus.Open)
                                        {
                                            if (valve.OpeningDegree > 0)
                                            {
                                                valveModel.LinkStatus = Yw.EPAnet.ValveStatus.None;
                                            }
                                        }
                                    }
                                }
                                break;
                            case Yw.Hydro.ValveType.GPV://常规阀门
                                {
                                    if (valve.Code == "694311")
                                    {

                                    }
                                    var curve_ql_code_list = valve.CurvesQL;
                                    if (curve_ql_code_list == null)
                                    {
                                        curve_ql_code_list = new List<string>();
                                    }
                                    var curvesql = model.Curves?.Where(x => curve_ql_code_list.Contains(x.Code)).ToList();
                                    var nearCurveql = curvesql?.OrderBy(x => Math.Abs(valve.OpeningDegree - x.CurveFactor ?? 0)).FirstOrDefault();
                                    if (nearCurveql != null)
                                    {
                                        valveModel.ValveSetting = nearCurveql.Code;
                                    }
                                }
                                break;
                            default: break;
                        }
                        netWork.Valves.Add(valveModel);
                    }
                }
            }

            //换热器
            if (model.Exchangers != null && model.Exchangers.Count > 0)
            {
                foreach (var exchanger in model.Exchangers)
                {
                    var exchangerModel = new Exchanger();
                    exchangerModel.Id = exchanger.Code;
                    exchangerModel.Catalog = Yw.EPAnet.Catalog.Exchanger;
                    exchangerModel.Name = exchanger.Name;
                    exchangerModel.StartNode = allNodes.Find(x => x.Id == exchanger.StartCode);
                    exchangerModel.EndNode = allNodes.Find(x => x.Id == exchanger.EndCode);
                    exchangerModel.LinkStatus = exchanger.LinkStatus;
                    exchangerModel.Diameter = exchanger.Diameter;
                    exchangerModel.MinorLoss = exchanger.MinorLoss;
                    exchangerModel.CurveQL = exchanger.CurveQL;
                    netWork.Exchangers.Add(exchangerModel);
                }
            }

            //压缩机
            if (model.Compressors != null && model.Compressors.Count > 0)
            {
                foreach (var compressor in model.Compressors)
                {
                    var compressModel = new Compressor();
                    compressModel.Id = compressor.Code;
                    compressModel.Catalog = Yw.EPAnet.Catalog.Compressor;
                    compressModel.Name = compressor.Name;
                    compressModel.StartNode = allNodes.Find(x => x.Id == compressor.StartCode);
                    compressModel.EndNode = allNodes.Find(x => x.Id == compressor.EndCode);
                    compressModel.LinkStatus = compressor.LinkStatus;
                    compressModel.Diameter = compressor.Diameter;
                    compressModel.MinorLoss = compressor.MinorLoss;
                    compressModel.CurveQL = compressor.CurveQL;
                    netWork.Compressors.Add(compressModel);
                }
            }

            //曲线
            if (model.Curves != null && model.Curves.Count > 0)
            {
                foreach (var curve in model.Curves)
                {
                    var curveModel = new Yw.EPAnet.Curve();
                    curveModel.Id = curve.Code;
                    curveModel.Catalog = Yw.EPAnet.Catalog.Curve;
                    curveModel.Name = curve.Name;
                    curveModel.CurveType = curve.CurveType;
                    curveModel.CurveData = curve.CurveData?.Select(x => new CurvePoint(x.X, x.Y)).ToList();
                    netWork.Curves.Add(curveModel);
                }
            }



            #endregion

            #region 节点连接

            var allLinks = netWork.GetAllLinks();
            foreach (var node in allNodes)
            {
                var links = allLinks.Where(x => x.StartNode.Id == node.Id || x.EndNode.Id == node.Id).ToList();
                node.Links = links;
            }

            #endregion

            return netWork;
        }




    }
}