// Copyright (C) Stichting Deltares 2024. All rights reserved.
// 
// This file is part of the Dam Engine.
// 
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
// 
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// 
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System.Collections.Generic;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.Results;
using Deltares.DamEngine.Data.General.TimeSeries;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.DamEngine.Io.XmlOutput;
using DesignResult = Deltares.DamEngine.Io.XmlOutput.DesignResult;
using TimeSerie = Deltares.DamEngine.Io.XmlOutput.TimeSerie;
using UpliftSituation = Deltares.DamEngine.Io.XmlOutput.UpliftSituation;

namespace Deltares.DamEngine.Interface;

/// <summary>
/// Class to fill the results in DamProjectData based on the output xml (for test purposes only)
/// </summary>
public class FillDamFromXmlOutput
{
    /// <summary>
    /// Creates the dam project data.
    /// </summary>
    /// <param name="damProjectData"></param>
    /// <param name="output">The output.</param>
    /// <returns></returns>
    public static DamProjectData CreateDamProjectData(DamProjectData damProjectData, Output output)
    {
        if (damProjectData == null)
        {
            damProjectData = new DamProjectData();
        }

        //var damProjectData = new DamProjectData();
        if (output != null && output.Results != null && output.Results.CalculationResults != null)
        {
            if (output.Results.CalculationResults != null)
            {
                CreateDesignResultsOutput(output, damProjectData);
            }
        }

        if (output != null && output.Results != null && output.Results.OperationalOutputTimeSeries != null)
        {
            damProjectData.OutputTimeSerieCollection = new TimeSerieCollection();
            TransferOutputTimeSeries(output.Results.OperationalOutputTimeSeries, damProjectData.OutputTimeSerieCollection);
        }

        return damProjectData;
    }

    private static void TransferOutputTimeSeries(TimeSerie[] outputTimeSeries, TimeSerieCollection outputTimeSerieCollection)
    {
        foreach (TimeSerie outputTimeSerie in outputTimeSeries)
        {
            Data.General.TimeSeries.TimeSerie timeSerie = outputTimeSerieCollection.AddNewSeries(outputTimeSerie.LocationId);
            timeSerie.ParameterId = outputTimeSerie.ParameterId;
            timeSerie.ForecastDateTime = outputTimeSerie.ForecastDateTime;
            timeSerie.Type = outputTimeSerie.Type;
            timeSerie.StartDateTime = outputTimeSerie.StartDateTime;
            timeSerie.EndDateTime = outputTimeSerie.EndDateTime;
            timeSerie.MissVal = outputTimeSerie.MissVal;
            timeSerie.LongName = outputTimeSerie.LongName;
            timeSerie.StationName = outputTimeSerie.StationName;
            timeSerie.Units = outputTimeSerie.Units;
            timeSerie.SourceOrganisation = outputTimeSerie.SourceOrganisation;
            timeSerie.SourceSystem = outputTimeSerie.SourceSystem;
            timeSerie.FileDescription = outputTimeSerie.FileDescription;
            timeSerie.Region = outputTimeSerie.Region;
            timeSerie.TimeStep.Multiplier = outputTimeSerie.TimeStep.Multiplier;
            timeSerie.TimeStep.Divider = outputTimeSerie.TimeStep.Divider;
            timeSerie.TimeStep.MultiplierSpecified = outputTimeSerie.TimeStep.MultiplierSpecified1;
            timeSerie.TimeStep.DividerSpecified = outputTimeSerie.TimeStep.DividerSpecified1;
            timeSerie.TimeStep.Unit = ConversionHelper.ConvertToTimeStepUnit(outputTimeSerie.TimeStep.TimeStepUnit);
            for (var i = 0; i < outputTimeSerie.Entries.TimeSerieEntry.Length; i++)
            {
                TimeSerieEntriesTimeSerieEntry entry = outputTimeSerie.Entries.TimeSerieEntry[i];
                // Stochast stochastValue = null;
                // if (entry.StochastValue != null)
                // {
                //     stochastValue = new Stochast
                //     {
                //         Distribution = entry.StochastValue.Distribution,
                //         Mean = entry.StochastValue.Mean,
                //         StandardDeviation = entry.StochastValue.StandardDeviation
                //     };
                // }

                var timeSerieEntry = new TimeSerieEntry
                {
                    DateTime = entry.DateTime,
                    Value = entry.SafetyFactor,
                    // BasisFileName = entry.BasisFileNameWMF,
                    // Flag = entry.Flagnietechtgebruikt,
                    // RelativeCalculationPathName = entry.RelativeCalculationPathName,
                    // StochastValue = stochastValue
                };
                timeSerie.Entries.Add(timeSerieEntry);
            }
        }
    }

    private static void CreateDesignResultsOutput(Output output, DamProjectData damProjectData)
    {
        // Design results
        damProjectData.DesignCalculations = new List<Data.General.Results.DesignResult>();
        for (var i = 0; i < output.Results.CalculationResults.Length; i++)
        {
            DesignResult designResult = output.Results.CalculationResults[i];
            var desResult = new Data.General.Results.DesignResult(designResult.LocationName, designResult.ScenarioName)
            {
                BaseFileName = designResult.BaseFileName,
                CalculationSubDir = designResult.CalculationSubDir,
                ProfileName = designResult.ProfileName,
                CalculationResult = ConversionHelper.ConvertToCalculationResult(designResult.CalculationResult)
            };

            if (designResult.PipingDesignResults != null)
            {
                CreateDesignResultsPipingOutput(designResult, desResult);
            }

            if (designResult.StabilityDesignResults != null)
            {
                CreateDesignResultsStabilityOutput(designResult, desResult);
            }

            damProjectData.DesignCalculations.Add(desResult);
        }

        if (output.Results.CalculationMessages != null)
        {
            damProjectData.CalculationMessages = new List<LogMessage>();
            for (var i = 0; i < output.Results.CalculationMessages.Length; i++)
            {
                Message validationResult = output.Results.CalculationMessages[i];
                var logMessage = new LogMessage
                {
                    MessageType = ConversionHelper.ConvertToLogMessageType(validationResult.MessageType),
                    Subject = null,
                    Message = validationResult.Message1
                };
                damProjectData.CalculationMessages.Add(logMessage);
            }
        }
    }

    private static void CreateDesignResultsPipingOutput(DesignResult designResult, Data.General.Results.DesignResult desResult)
    {
        var model = PipingModelType.Bligh;
        if (designResult.PipingDesignResults.Wti2017BackwardErosionFactorSpecified)
        {
            model = PipingModelType.Wti2017;
        }

        desResult.PipingDesignResults = new PipingDesignResults(model)
        {
            ResultMessage = designResult.PipingDesignResults.ResultMessage
        };
        if (designResult.PipingDesignResults.RedesignedSurfaceLine != null)
        {
            desResult.PipingDesignResults.RedesignedSurfaceLine = new SurfaceLine2
            {
                Name = designResult.PipingDesignResults.RedesignedSurfaceLine.Name
            };
            desResult.PipingDesignResults.RedesignedSurfaceLine.CharacteristicPoints.Geometry = desResult.PipingDesignResults.RedesignedSurfaceLine.Geometry;
            AddPointsToSurfaceLine(designResult.PipingDesignResults.RedesignedSurfaceLine, desResult.PipingDesignResults.RedesignedSurfaceLine);
        }

        if (designResult.PipingDesignResults.UpliftFactorSpecified)
        {
            desResult.PipingDesignResults.UpliftFactor = designResult.PipingDesignResults.UpliftFactor;
        }

        if (designResult.PipingDesignResults.HeaveFactorSpecified)
        {
            desResult.PipingDesignResults.HeaveFactor = designResult.PipingDesignResults.HeaveFactor;
        }

        if (designResult.PipingDesignResults.BlighFactorSpecified)
        {
            desResult.PipingDesignResults.BlighFactor = designResult.PipingDesignResults.BlighFactor;
        }

        if (designResult.PipingDesignResults.BlighHcriticalSpecified)
        {
            desResult.PipingDesignResults.BlighHcritical = designResult.PipingDesignResults.BlighHcritical;
        }

        if (designResult.PipingDesignResults.Wti2017BackwardErosionFactorSpecified)
        {
            desResult.PipingDesignResults.Wti2017BackwardErosionSafetyFactor = designResult.PipingDesignResults.Wti2017BackwardErosionFactor;
        }

        if (designResult.PipingDesignResults.Wti2017BackwardErosionHcriticalSpecified)
        {
            desResult.PipingDesignResults.Wti2017BackwardErosionHcritical = designResult.PipingDesignResults.Wti2017BackwardErosionHcritical;
        }

        if (designResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiCSpecified)
        {
            desResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiC = designResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiC;
        }

        if (designResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReducedSpecified)
        {
            desResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReduced = designResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReduced;
        }

        if (designResult.PipingDesignResults.Wti2017UpliftFactorSpecified)
        {
            desResult.PipingDesignResults.Wti2017UpliftSafetyFactor = designResult.PipingDesignResults.Wti2017UpliftFactor;
        }

        if (designResult.PipingDesignResults.Wti2017UpliftHcriticalSpecified)
        {
            desResult.PipingDesignResults.Wti2017UpliftHcritical = designResult.PipingDesignResults.Wti2017UpliftHcritical;
        }

        if (designResult.PipingDesignResults.Wti2017DeltaPhiCuSpecified)
        {
            desResult.PipingDesignResults.Wti2017UpliftDeltaPhiC = designResult.PipingDesignResults.Wti2017DeltaPhiCu;
        }

        if (designResult.PipingDesignResults.Wti2017HeaveFactorSpecified)
        {
            desResult.PipingDesignResults.Wti2017HeaveSafetyFactor = designResult.PipingDesignResults.Wti2017HeaveFactor;
        }

        if (designResult.PipingDesignResults.Wti2017HeaveHcriticalSpecified)
        {
            desResult.PipingDesignResults.Wti2017HeaveHcritical = designResult.PipingDesignResults.Wti2017HeaveHcritical;
        }

        if (designResult.PipingDesignResults.Wti2017GradientSpecified)
        {
            desResult.PipingDesignResults.Wti2017Gradient = designResult.PipingDesignResults.Wti2017Gradient;
        }

        if (designResult.PipingDesignResults.Wti2017FactorOverallSpecified)
        {
            desResult.PipingDesignResults.Wti2017SafetyFactorOverall = designResult.PipingDesignResults.Wti2017FactorOverall;
        }

        if (designResult.PipingDesignResults.Wti2017HcriticalOverallSpecified)
        {
            desResult.PipingDesignResults.Wti2017HcriticalOverall = designResult.PipingDesignResults.Wti2017HcriticalOverall;
        }

        if (designResult.PipingDesignResults.ExitPointXSpecified)
        {
            desResult.PipingDesignResults.LocalExitPointX = designResult.PipingDesignResults.ExitPointX;
        }

        if (designResult.PipingDesignResults.Wti2017EffectiveStressSpecified)
        {
            desResult.PipingDesignResults.EffectiveStress = designResult.PipingDesignResults.Wti2017EffectiveStress;
        }

        if (designResult.PipingDesignResults.Wti2017CCreepSpecified)
        {
            desResult.PipingDesignResults.CCreep = designResult.PipingDesignResults.Wti2017CCreep;
        }

        if (designResult.PipingDesignResults.UpliftSituation != null)
        {
            UpliftSituation uplift = designResult.PipingDesignResults.UpliftSituation;
            var situation = new Data.General.UpliftSituation
            {
                IsUplift = uplift.IsUplift,
                Pl3MinUplift = uplift.Pl3MinUplift,
                Pl3HeadAdjusted = uplift.Pl3HeadAdjusted,
                Pl3LocationXMinUplift = uplift.Pl3LocationXMinUplift,
                Pl4MinUplift = uplift.Pl4MinUplift,
                Pl4HeadAdjusted = uplift.Pl4HeadAdjusted,
                Pl4LocationXMinUplift = uplift.Pl4LocationXMinUplift
            };
            desResult.PipingDesignResults.UpliftSituation = situation;
        }
    }

    private static void AddPointsToSurfaceLine(SurfaceLine inputSurfaceLine, SurfaceLine2 surfaceLine)
    {
        surfaceLine.Geometry = new GeometryPointString();
        for (var j = 0; j < inputSurfaceLine.Points.Length; j++)
        {
            SurfaceLinePoint inputPoint = inputSurfaceLine.Points[j];
            var geometryPoint = new Point2D()
            {
                X = inputPoint.X,
                Z = inputPoint.Z
            };
            surfaceLine.AddCharacteristicPoint(geometryPoint, ConversionHelper.ConvertToDamPointType(inputPoint.PointType));
        }
    }

    private static void CreateDesignResultsStabilityOutput(DesignResult designResult, Data.General.Results.DesignResult desResult)
    {
        desResult.StabilityDesignResults = new StabilityDesignResults
        {
            ResultMessage = designResult.StabilityDesignResults.ResultMessage
        };
        if (designResult.StabilityDesignResults.RedesignedSurfaceLine != null)
        {
            desResult.StabilityDesignResults.RedesignedSurfaceLine = new SurfaceLine2
            {
                Name = designResult.StabilityDesignResults.RedesignedSurfaceLine.Name
            };
            desResult.StabilityDesignResults.RedesignedSurfaceLine.CharacteristicPoints.Geometry = desResult.StabilityDesignResults.RedesignedSurfaceLine.Geometry;
            AddPointsToSurfaceLine(designResult.StabilityDesignResults.RedesignedSurfaceLine, desResult.StabilityDesignResults.RedesignedSurfaceLine);
        }

        if (designResult.StabilityDesignResults.SafetyFactorSpecified)
        {
            desResult.StabilityDesignResults.SafetyFactor = designResult.StabilityDesignResults.SafetyFactor;
        }

        if (designResult.StabilityDesignResults.NumberOfIterationsSpecified)
        {
            desResult.StabilityDesignResults.NumberOfIterations = designResult.StabilityDesignResults.NumberOfIterations;
        }

        if (designResult.StabilityDesignResults.UpliftSituation != null)
        {
            UpliftSituation uplift = designResult.StabilityDesignResults.UpliftSituation;
            var situation = new Data.General.UpliftSituation
            {
                IsUplift = uplift.IsUplift,
                Pl3MinUplift = uplift.Pl3MinUplift,
                Pl3HeadAdjusted = uplift.Pl3HeadAdjusted,
                Pl3LocationXMinUplift = uplift.Pl3LocationXMinUplift,
                Pl4MinUplift = uplift.Pl4MinUplift,
                Pl4HeadAdjusted = uplift.Pl4HeadAdjusted,
                Pl4LocationXMinUplift = uplift.Pl4LocationXMinUplift
            };
            desResult.StabilityDesignResults.UpliftSituation = situation;
        }

        if (designResult.StabilityDesignResults.StabilityModelTypeSpecified)
        {
            desResult.StabilityDesignResults.StabilityModelType = ConversionHelper.ConvertToStabilityModelType(designResult.StabilityDesignResults.StabilityModelType);
        }

        if (designResult.StabilityDesignResults.SlipCircleDefinition != null)
        {
            bool isBishop = designResult.StabilityDesignResults.StabilityModelType == DesignResultStabilityDesignResultsStabilityModelType.Bishop;
            bool isUpliftVan = designResult.StabilityDesignResults.StabilityModelType == DesignResultStabilityDesignResultsStabilityModelType.UpliftVan;
            if (designResult.StabilityDesignResults.StabilityModelType == DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan)
            {
                isBishop = designResult.StabilityDesignResults.SlipCircleDefinition is SlidingCircleMinimumSafetyCurveType;
                isUpliftVan = designResult.StabilityDesignResults.SlipCircleDefinition is DualSlidingCircleMinimumSafetyCurveType;
            }

            if (isBishop)
            {
                var singleSlipCircleDefinition = (SlidingCircleMinimumSafetyCurveType) designResult.StabilityDesignResults.SlipCircleDefinition;
                desResult.StabilityDesignResults.ActiveCenterPoint = new Point2D(singleSlipCircleDefinition.Center.X, singleSlipCircleDefinition.Center.Z);
                desResult.StabilityDesignResults.ActiveCenterPointRadius = singleSlipCircleDefinition.Radius;
            }

            if (isUpliftVan)
            {
                var dualSlipCircleDefinition = (DualSlidingCircleMinimumSafetyCurveType) designResult.StabilityDesignResults.SlipCircleDefinition;
                desResult.StabilityDesignResults.ActiveCenterPoint = new Point2D(dualSlipCircleDefinition.ActiveCircleCenter.X, dualSlipCircleDefinition.ActiveCircleCenter.Z);
                desResult.StabilityDesignResults.ActiveCenterPointRadius = dualSlipCircleDefinition.ActiveCircleRadius;
                desResult.StabilityDesignResults.PassiveCenterPoint = new Point2D(dualSlipCircleDefinition.PassiveCircleCenter.X, dualSlipCircleDefinition.PassiveCircleCenter.Z);
                desResult.StabilityDesignResults.PassiveCenterPointRadius = dualSlipCircleDefinition.PassiveCircleRadius;
            }

            if (designResult.StabilityDesignResults.StabilityModelType is 
                DesignResultStabilityDesignResultsStabilityModelType.Bishop or 
                DesignResultStabilityDesignResultsStabilityModelType.UpliftVan or 
                DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan)
            {
                if (designResult.StabilityDesignResults.SlipCircleDefinition.Slices != null)
                {
                    desResult.StabilityDesignResults.ResultSlices = new List<StabilityResultSlice>();
                    foreach (MinimumSafetyCurveBaseTypeSlice slice in designResult.StabilityDesignResults.SlipCircleDefinition.Slices)
                    {
                        var resultSlice = new StabilityResultSlice();
                        resultSlice.TopLeftPoint = new Point2D(slice.TopLeftPoint.X, slice.TopLeftPoint.Z);
                        resultSlice.TopRightPoint = new Point2D(slice.TopRightPoint.X, slice.TopRightPoint.Z);
                        resultSlice.BottomLeftPoint = new Point2D(slice.BottomLeftPoint.X, slice.BottomLeftPoint.Z);
                        resultSlice.BottomRightPoint =
                            new Point2D(slice.BottomRightPoint.X, slice.BottomRightPoint.Z);
                        desResult.StabilityDesignResults.ResultSlices.Add(resultSlice);
                    }
                }
            }
        }
    }
}