// Copyright (C) Stichting Deltares 2019. 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 Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.TimeSeries;
using Deltares.DamEngine.Io.XmlOutput;
using TimeSerie = Deltares.DamEngine.Io.XmlOutput.TimeSerie;

namespace Deltares.DamEngine.Interface
{
    /// <summary>
    /// Class to fill the output xml based on the results in DamProjectData
    /// </summary>
    public class FillXmlOutputFromDam
    {
        /// <summary>
        /// Creates the output.
        /// </summary>
        /// <param name="damProjectData">The dam project data.</param>
        /// <returns></returns>
        public static Output CreateOutput(DamProjectData damProjectData)
        {
            // Echo of the input
            Output output = new Output
            {
                ValidationResults = new Message[0],
                // Results
                Results = new OutputResults
                {
                    // Calculation messages
                    CalculationMessages = new Message[damProjectData.CalculationMessages.Count],                    
                }
            };
            CreateCalculationMessages(damProjectData, output);
            CreateDesignResultsOutput(damProjectData, output);
            CreateLocationResultsOutput(damProjectData, output);
            return output;
        }

        private static void CreateDesignResultsOutput(DamProjectData damProjectData, Output output)
        {
            // Design results
            var designResults = damProjectData.DesignCalculations;
            if (designResults != null && designResults.Count > 0)
            {
                output.Results.CalculationResults = new DesignResult[designResults.Count];
                var designResultCount = 0;
                foreach (var designResult in designResults)
                {
                    var desResult = new DesignResult
                    {
                        BaseFileName = designResult.BaseFileName,
                        CalculationSubDir = designResult.CalculationSubDir,
                        LocationName = designResult.LocationName,
                        ScenarioName = designResult.ScenarioName,
                        ProfileName = designResult.ProfileName,
                        CalculationResult = ConversionHelper.ConvertToOutputCalculationResult(designResult.CalculationResult),
                    };


                    if (designResult.PipingDesignResults != null)
                    {
                        CreateDesignResultsPipingOutput(desResult, designResult);
                    }
                    if (designResult.StabilityDesignResults != null)
                    {
                        CreateDesignResultsStabilityOutput(desResult, designResult);
                    }
                    output.Results.CalculationResults[designResultCount] = desResult;
                    designResultCount++;
                }
            }
        }

        private static void CreateCalculationMessages(DamProjectData damProjectData, Output output)
        {
            var calculationMessages = damProjectData.CalculationMessages;
            if (calculationMessages != null)
            {
                output.Results.CalculationMessages = new Message[calculationMessages.Count];
                for (int i = 0; i < calculationMessages.Count; i++)
                {
                    var message = new Message
                    {
                        MessageType = ConversionHelper.ConvertToInputMessageType(calculationMessages[i].MessageType)                        
                    };
                    if (calculationMessages[i].Subject != null)
                    {
                        message.Message1 = calculationMessages[i].Subject + ": " + calculationMessages[i].Message;
                    }
                    else
                    {
                        message.Message1 = calculationMessages[i].Message;
                    }
                    output.Results.CalculationMessages[i] = message;
                }
            }
        }

        private static void CreateDesignResultsPipingOutput(DesignResult desResult, Data.General.Results.DesignResult designResult)
        {
            desResult.PipingDesignResults = new DesignResultPipingDesignResults
            {
                ResultMessage = designResult.PipingDesignResults.ResultMessage
            };
            if (designResult.PipingDesignResults.RedesignedSurfaceLine != null)
            {
                desResult.PipingDesignResults.RedesignedSurfaceLine = new SurfaceLine
                {
                    Name = designResult.PipingDesignResults.RedesignedSurfaceLine.Name,
                    Points = new SurfaceLinePoint[designResult.PipingDesignResults.RedesignedSurfaceLine.CharacteristicPoints.Count]
                };
                for (int j = 0; j < designResult.PipingDesignResults.RedesignedSurfaceLine.CharacteristicPoints.Count; j++)
                {
                    var characteristicPoint = designResult.PipingDesignResults.RedesignedSurfaceLine.CharacteristicPoints[j];
                    var inputPoint = new SurfaceLinePoint()
                    {
                        PointType = ConversionHelper.ConvertToInputPointType(characteristicPoint.CharacteristicPointType),
                        X = characteristicPoint.X,
                        Z = characteristicPoint.Z
                    };
                    desResult.PipingDesignResults.RedesignedSurfaceLine.Points[j] = inputPoint;
                }
            }

            desResult.PipingDesignResults.UpliftFactorSpecified = designResult.PipingDesignResults.UpliftFactor.HasValue;
            if (designResult.PipingDesignResults.UpliftFactor.HasValue) desResult.PipingDesignResults.UpliftFactor = designResult.PipingDesignResults.UpliftFactor.Value;

            desResult.PipingDesignResults.HeaveFactorSpecified = designResult.PipingDesignResults.HeaveFactor.HasValue;
            if (designResult.PipingDesignResults.HeaveFactor.HasValue) desResult.PipingDesignResults.HeaveFactor = designResult.PipingDesignResults.HeaveFactor.Value;

            desResult.PipingDesignResults.BlighFactorSpecified = designResult.PipingDesignResults.BlighFactor.HasValue;
            if (designResult.PipingDesignResults.BlighFactor.HasValue) desResult.PipingDesignResults.BlighFactor = designResult.PipingDesignResults.BlighFactor.Value;

            desResult.PipingDesignResults.BlighHcriticalSpecified = designResult.PipingDesignResults.BlighHcritical.HasValue;
            if (designResult.PipingDesignResults.BlighHcritical.HasValue) desResult.PipingDesignResults.BlighHcritical = designResult.PipingDesignResults.BlighHcritical.Value;

            desResult.PipingDesignResults.Sellmeijer4ForcesFactorSpecified = designResult.PipingDesignResults.Sellmeijer4ForcesFactor.HasValue;
            if (designResult.PipingDesignResults.Sellmeijer4ForcesFactor.HasValue) desResult.PipingDesignResults.Sellmeijer4ForcesFactor = designResult.PipingDesignResults.Sellmeijer4ForcesFactor.Value;

            desResult.PipingDesignResults.Sellmeijer4ForcesHcriticalSpecified = designResult.PipingDesignResults.Sellmeijer4ForcesHcritical.HasValue;
            if (designResult.PipingDesignResults.Sellmeijer4ForcesHcritical.HasValue) desResult.PipingDesignResults.Sellmeijer4ForcesHcritical = designResult.PipingDesignResults.Sellmeijer4ForcesHcritical.Value;

            desResult.PipingDesignResults.SellmeijerVnkFactorSpecified = designResult.PipingDesignResults.SellmeijerVnkFactor.HasValue;
            if (designResult.PipingDesignResults.SellmeijerVnkFactor.HasValue) desResult.PipingDesignResults.SellmeijerVnkFactor = designResult.PipingDesignResults.SellmeijerVnkFactor.Value;

            desResult.PipingDesignResults.SellmeijerVnkHcriticalSpecified = designResult.PipingDesignResults.SellmeijerVnkHcritical.HasValue;
            if (designResult.PipingDesignResults.SellmeijerVnkHcritical.HasValue) desResult.PipingDesignResults.SellmeijerVnkHcritical = designResult.PipingDesignResults.SellmeijerVnkHcritical.Value;

            desResult.PipingDesignResults.Wti2017BackwardErosionFactorSpecified = designResult.PipingDesignResults.Wti2017BackwardErosionSafetyFactor.HasValue;
            if (designResult.PipingDesignResults.Wti2017BackwardErosionSafetyFactor.HasValue) desResult.PipingDesignResults.Wti2017BackwardErosionFactor = designResult.PipingDesignResults.Wti2017BackwardErosionSafetyFactor.Value;

            desResult.PipingDesignResults.Wti2017BackwardErosionHcriticalSpecified = designResult.PipingDesignResults.Wti2017BackwardErosionHcritical.HasValue;
            if (designResult.PipingDesignResults.Wti2017BackwardErosionHcritical.HasValue) desResult.PipingDesignResults.Wti2017BackwardErosionHcritical = designResult.PipingDesignResults.Wti2017BackwardErosionHcritical.Value;

            desResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiCSpecified = designResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiC.HasValue;
            if (designResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiC.HasValue) desResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiC = designResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiC.Value;

            desResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReducedSpecified = designResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReduced.HasValue;
            if (designResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReduced.HasValue) desResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReduced = designResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReduced.Value;

            desResult.PipingDesignResults.Wti2017UpliftFactorSpecified = designResult.PipingDesignResults.Wti2017UpliftSafetyFactor.HasValue;
            if (designResult.PipingDesignResults.Wti2017UpliftSafetyFactor.HasValue) desResult.PipingDesignResults.Wti2017UpliftFactor = designResult.PipingDesignResults.Wti2017UpliftSafetyFactor.Value;

            desResult.PipingDesignResults.Wti2017UpliftHcriticalSpecified = designResult.PipingDesignResults.Wti2017UpliftHcritical.HasValue;
            if (designResult.PipingDesignResults.Wti2017UpliftHcritical.HasValue) desResult.PipingDesignResults.Wti2017UpliftHcritical = designResult.PipingDesignResults.Wti2017UpliftHcritical.Value;

            desResult.PipingDesignResults.Wti2017DeltaPhiCuSpecified = designResult.PipingDesignResults.Wti2017UpliftDeltaPhiC.HasValue;
            if (designResult.PipingDesignResults.Wti2017UpliftDeltaPhiC.HasValue) desResult.PipingDesignResults.Wti2017DeltaPhiCu = designResult.PipingDesignResults.Wti2017UpliftDeltaPhiC.Value;

            desResult.PipingDesignResults.Wti2017HeaveFactorSpecified = designResult.PipingDesignResults.Wti2017HeaveSafetyFactor.HasValue;
            if (designResult.PipingDesignResults.Wti2017HeaveSafetyFactor.HasValue) desResult.PipingDesignResults.Wti2017HeaveFactor = designResult.PipingDesignResults.Wti2017HeaveSafetyFactor.Value;

            desResult.PipingDesignResults.Wti2017HeaveHcriticalSpecified = designResult.PipingDesignResults.Wti2017HeaveHcritical.HasValue;
            if (designResult.PipingDesignResults.Wti2017HeaveHcritical.HasValue) desResult.PipingDesignResults.Wti2017HeaveHcritical = designResult.PipingDesignResults.Wti2017HeaveHcritical.Value;

            desResult.PipingDesignResults.Wti2017GradientSpecified = designResult.PipingDesignResults.Wti2017Gradient.HasValue;
            if (designResult.PipingDesignResults.Wti2017Gradient.HasValue) desResult.PipingDesignResults.Wti2017Gradient = designResult.PipingDesignResults.Wti2017Gradient.Value;

            desResult.PipingDesignResults.Wti2017FactorOverallSpecified = designResult.PipingDesignResults.Wti2017SafetyFactorOverall.HasValue;
            if (designResult.PipingDesignResults.Wti2017SafetyFactorOverall.HasValue) desResult.PipingDesignResults.Wti2017FactorOverall = designResult.PipingDesignResults.Wti2017SafetyFactorOverall.Value;

            desResult.PipingDesignResults.Wti2017HcriticalOverallSpecified = designResult.PipingDesignResults.Wti2017HcriticalOverall.HasValue;
            if (designResult.PipingDesignResults.Wti2017HcriticalOverall.HasValue) desResult.PipingDesignResults.Wti2017HcriticalOverall = designResult.PipingDesignResults.Wti2017HcriticalOverall.Value;

            desResult.PipingDesignResults.ExitPointXSpecified = designResult.PipingDesignResults.LocalExitPointX.HasValue;
            if (designResult.PipingDesignResults.LocalExitPointX.HasValue) desResult.PipingDesignResults.ExitPointX = designResult.PipingDesignResults.LocalExitPointX.Value;

            desResult.PipingDesignResults.Wti2017EffectiveStressSpecified = designResult.PipingDesignResults.EffectiveStress.HasValue;
            if (designResult.PipingDesignResults.EffectiveStress.HasValue) desResult.PipingDesignResults.Wti2017EffectiveStress = designResult.PipingDesignResults.EffectiveStress.Value;

            desResult.PipingDesignResults.Wti2017CCreepSpecified = designResult.PipingDesignResults.CCreep.HasValue;
            if (designResult.PipingDesignResults.CCreep.HasValue) desResult.PipingDesignResults.Wti2017CCreep = designResult.PipingDesignResults.CCreep.Value;

            if (designResult.PipingDesignResults.UpliftSituation.HasValue)
            {
                var uplift = designResult.PipingDesignResults.UpliftSituation.Value;
                desResult.PipingDesignResults.UpliftSituation = new Io.XmlOutput.UpliftSituation
                {
                    IsUplift = uplift.IsUplift,
                    Pl3MinUplift = uplift.Pl3MinUplift,
                    Pl3HeadAdjusted = uplift.Pl3HeadAdjusted,
                    Pl3LocationXMinUplift = uplift.Pl3LocationXMinUplift,
                    Pl4MinUplift = uplift.Pl4MinUplift,
                    Pl4HeadAdjusted = uplift.Pl4HeadAdjusted,
                    Pl4LocationXMinUplift = uplift.Pl4LocationXMinUplift
                };
            }
        }


        private static void CreateDesignResultsStabilityOutput(DesignResult desResult, Data.General.Results.DesignResult designResult)
        {
            desResult.StabilityDesignResults = new DesignResultStabilityDesignResults()
            {
                ResultMessage = designResult.StabilityDesignResults.ResultMessage
            };

            if (designResult.StabilityDesignResults.UpliftSituation.HasValue)
            {
                var uplift = designResult.StabilityDesignResults.UpliftSituation.Value;
                desResult.StabilityDesignResults.UpliftSituation = new Io.XmlOutput.UpliftSituation
                {
                    IsUplift = uplift.IsUplift,
                    Pl3MinUplift = uplift.Pl3MinUplift,
                    Pl3HeadAdjusted = uplift.Pl3HeadAdjusted,
                    Pl3LocationXMinUplift = uplift.Pl3LocationXMinUplift,
                    Pl4MinUplift = uplift.Pl4MinUplift,
                    Pl4HeadAdjusted = uplift.Pl4HeadAdjusted,
                    Pl4LocationXMinUplift = uplift.Pl4LocationXMinUplift
                };
            }

            if (designResult.StabilityDesignResults.RedesignedSurfaceLine != null)
            {
                desResult.StabilityDesignResults.RedesignedSurfaceLine = new SurfaceLine
                {
                    Name = designResult.StabilityDesignResults.RedesignedSurfaceLine.Name,
                    Points = new SurfaceLinePoint[designResult.StabilityDesignResults.RedesignedSurfaceLine.CharacteristicPoints.Count]
                };
                for (int j = 0; j < designResult.StabilityDesignResults.RedesignedSurfaceLine.CharacteristicPoints.Count; j++)
                {
                    var characteristicPoint = designResult.StabilityDesignResults.RedesignedSurfaceLine.CharacteristicPoints[j];
                    var inputPoint = new SurfaceLinePoint()
                    {
                        PointType = ConversionHelper.ConvertToInputPointType(characteristicPoint.CharacteristicPointType),
                        X = characteristicPoint.X,
                        Z = characteristicPoint.Z
                    };
                    desResult.StabilityDesignResults.RedesignedSurfaceLine.Points[j] = inputPoint;
                }
            }

            if (designResult.StabilityDesignResults != null)
            {
                switch(designResult.StabilityDesignResults.StabilityModelType)
                {
                    case MStabModelType.Bishop:
                        desResult.StabilityDesignResults.SlipCircleDefinition = new SlidingCircleMinimumSafetyCurveType();
                        var sl = (SlidingCircleMinimumSafetyCurveType) desResult.StabilityDesignResults.SlipCircleDefinition;

                        if (designResult.StabilityDesignResults.ActiveCenterPoint != null)
                        {
                            sl.Center = new Point2DType()
                            {
                                X = designResult.StabilityDesignResults.ActiveCenterPoint.X,
                                Z = designResult.StabilityDesignResults.ActiveCenterPoint.Z
                            };
                            sl.Radius = designResult.StabilityDesignResults.ActiveCenterPointRadius;
                        }

                        break;

                    case MStabModelType.UpliftVan:
                        desResult.StabilityDesignResults.SlipCircleDefinition = new DualSlidingCircleMinimumSafetyCurveType();
                        var dsl = (DualSlidingCircleMinimumSafetyCurveType) desResult.StabilityDesignResults.SlipCircleDefinition;
                        if (designResult.StabilityDesignResults.ActiveCenterPoint != null)
                        {
                            dsl.ActiveCircleCenter = new Point2DType()
                            {
                                X = designResult.StabilityDesignResults.ActiveCenterPoint.X,
                                Z = designResult.StabilityDesignResults.ActiveCenterPoint.Z
                            };
                        dsl.ActiveCircleRadius = designResult.StabilityDesignResults.ActiveCenterPointRadius;
                        }

                        if (designResult.StabilityDesignResults.PassiveCenterPoint != null)
                        {
                            dsl.PassiveCircleCenter = new Point2DType()
                            {
                                X = designResult.StabilityDesignResults.PassiveCenterPoint.X,
                                Z = designResult.StabilityDesignResults.PassiveCenterPoint.Z
                            };
                            dsl.PassiveCircleRadius = designResult.StabilityDesignResults.PassiveCenterPointRadius;
                        }
                        break;
                }
            }


            desResult.StabilityDesignResults.SafetyFactorSpecified = designResult.StabilityDesignResults.SafetyFactor.HasValue;
            if (designResult.StabilityDesignResults.SafetyFactor.HasValue) desResult.StabilityDesignResults.SafetyFactor = designResult.StabilityDesignResults.SafetyFactor.Value;

            desResult.StabilityDesignResults.NumberOfIterationsSpecified = designResult.StabilityDesignResults.NumberOfIterations.HasValue;
            if (designResult.StabilityDesignResults.NumberOfIterations.HasValue) desResult.StabilityDesignResults.NumberOfIterations = designResult.StabilityDesignResults.NumberOfIterations.Value;

            desResult.StabilityDesignResults.StabilityModelTypeSpecified = designResult.StabilityDesignResults.StabilityModelType.HasValue;
            if (designResult.StabilityDesignResults.StabilityModelType.HasValue)
            {
                desResult.StabilityDesignResults.StabilityModelType = ConversionHelper.ConvertToOutputStabilityModelType(designResult.StabilityDesignResults.StabilityModelType.Value);
            }
        }

        private static void CreateLocationResultsOutput(DamProjectData damProjectData, Output output)
        {
            // Calculation results (per location)
            //output.Results.CalculationResults.LocationResults = new CalculationResultsLocationResult[damProjectData.LocationJobs.Count];
            if (damProjectData.OutputTimeSerieCollection != null)
            {
                output.Results.OperationalOutputTimeSeries = new TimeSerie[damProjectData.OutputTimeSerieCollection.Series.Count];
                TransferOutputTimeSeries(damProjectData.OutputTimeSerieCollection, output.Results.OperationalOutputTimeSeries);
            }
        }

        private static void TransferOutputTimeSeries(TimeSerieCollection outputTimeSerieCollection, TimeSerie[] outputTimeSeries)
        {
            int timeSerieIndex = 0;
            foreach (var damTimeSerie in outputTimeSerieCollection.Series)
            {
                TimeSerie outputTimeSerie = new TimeSerie();
                outputTimeSerie.Entries = new TimeSerieEntries();
                outputTimeSerie.Entries.TimeSerieEntry = new TimeSerieEntriesTimeSerieEntry[damTimeSerie.Entries.Count];
                outputTimeSerie.TimeStep = new TimeSerieTimeStep();
                outputTimeSerie.LocationId = damTimeSerie.LocationId;
                outputTimeSerie.ParameterId = damTimeSerie.ParameterId;
                outputTimeSerie.ForecastDateTime = damTimeSerie.ForecastDateTime;
                outputTimeSerie.Type = damTimeSerie.Type;
                outputTimeSerie.StartDateTime = damTimeSerie.StartDateTime;
                outputTimeSerie.EndDateTime = damTimeSerie.EndDateTime;
                outputTimeSerie.MissVal = damTimeSerie.MissVal;
                outputTimeSerie.LongName = damTimeSerie.LongName;
                outputTimeSerie.StationName = damTimeSerie.StationName;
                outputTimeSerie.Units = damTimeSerie.Units;
                outputTimeSerie.SourceOrganisation = damTimeSerie.SourceOrganisation;
                outputTimeSerie.SourceSystem = damTimeSerie.SourceSystem;
                outputTimeSerie.FileDescription = damTimeSerie.FileDescription;
                outputTimeSerie.Region = damTimeSerie.Region;
                outputTimeSerie.TimeStep.Multiplier = damTimeSerie.TimeStep.Multiplier;
                outputTimeSerie.TimeStep.Divider = damTimeSerie.TimeStep.Divider;
                outputTimeSerie.TimeStep.MultiplierSpecified1 = damTimeSerie.TimeStep.MultiplierSpecified;
                outputTimeSerie.TimeStep.DividerSpecified1 = damTimeSerie.TimeStep.DividerSpecified;
                outputTimeSerie.TimeStep.TimeStepUnit = ConversionHelper.ConvertToInputTimeStepUnit(damTimeSerie.TimeStep.Unit);
                int timeSerieEntryIndex = 0;
                foreach (var timestepEntry in damTimeSerie.Entries)
                {
                    TimeSerieEntriesTimeSerieEntryStochastValue stochastValue = null;
                    if (timestepEntry.StochastValue != null)
                    {
                        stochastValue = new TimeSerieEntriesTimeSerieEntryStochastValue()
                        {
                            Distribution = timestepEntry.StochastValue.Distribution,
                            Mean = timestepEntry.StochastValue.Mean,
                            StandardDeviation = timestepEntry.StochastValue.StandardDeviation
                        };
                    }
                    TimeSerieEntriesTimeSerieEntry timeStep = new TimeSerieEntriesTimeSerieEntry()
                    {
                        DateTime = timestepEntry.DateTime,
                        Value = timestepEntry.Value,
                        BasisFileNameWMF = timestepEntry.BasisFileName,
                        Flagnietechtgebruikt = timestepEntry.Flag,
                        RelativeCalculationPathName = timestepEntry.RelativeCalculationPathName,
                        StochastValue = stochastValue
                    };
                    outputTimeSerie.Entries.TimeSerieEntry[timeSerieEntryIndex] = timeStep;
                    timeSerieEntryIndex++;
                }
                outputTimeSeries[timeSerieIndex] = outputTimeSerie;
                timeSerieIndex++;
            }
        }
    }
}