// Copyright (C) Stichting Deltares 2018. 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 System.Linq;
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.RegionalAssessmentResults;
using Deltares.DamEngine.Data.Standard;
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;

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.DesignResults != null)
                {
                    CreateDesignResultsOutput(output, damProjectData);
                }
                if (output.Results.CalculationResults.LocationResults != null)
                {
                    CreateLocationResultsOutput(output, damProjectData);
                }
            }
            if (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 (var outputTimeSerie in outputTimeSeries)
            {
                var 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 (int i = 0; i < outputTimeSerie.Entries.TimeSerieEntry.Length; i++)
                {
                    var 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
                        };
                    }
                    TimeSerieEntry timeSerieEntry = new TimeSerieEntry()
                    {
                        DateTime = entry.DateTime,
                        Value = entry.Value,
                        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 (int i = 0; i < output.Results.CalculationResults.DesignResults.Length; i++)
            {
                var designResult = output.Results.CalculationResults.DesignResults[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 (int i = 0; i < output.Results.CalculationMessages.Length; i++)
                {
                    var 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.Sellmeijer4ForcesFactorSpecified)
                model = PipingModelType.Sellmeijer4Forces;
            if (designResult.PipingDesignResults.SellmeijerVnkFactorSpecified)
                model = PipingModelType.SellmeijerVnk;
            if (designResult.PipingDesignResults.Wbi2017BackwardErosionFactorSpecified)
                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.Sellmeijer4ForcesFactorSpecified) desResult.PipingDesignResults.Sellmeijer4ForcesFactor = designResult.PipingDesignResults.Sellmeijer4ForcesFactor;

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

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

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

            if (designResult.PipingDesignResults.Wbi2017BackwardErosionFactorSpecified) desResult.PipingDesignResults.Wti2017BackwardErosionSafetyFactor = designResult.PipingDesignResults.Wbi2017BackwardErosionFactor;

            if (designResult.PipingDesignResults.Wbi2017BackwardErosionHcriticalSpecified) desResult.PipingDesignResults.Wti2017BackwardErosionHcritical = designResult.PipingDesignResults.Wbi2017BackwardErosionHcritical;

            if (designResult.PipingDesignResults.Wbi2017BackwardErosionDeltaPhiCSpecified) desResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiC = designResult.PipingDesignResults.Wbi2017BackwardErosionDeltaPhiC;

            if (designResult.PipingDesignResults.Wbi2017BackwardErosionDeltaPhiReducedSpecified) desResult.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReduced = designResult.PipingDesignResults.Wbi2017BackwardErosionDeltaPhiReduced;

            if (designResult.PipingDesignResults.Wbi2017UpliftFactorSpecified) desResult.PipingDesignResults.Wti2017UpliftSafetyFactor = designResult.PipingDesignResults.Wbi2017UpliftFactor;

            if (designResult.PipingDesignResults.Wbi2017UpliftHcriticalSpecified) desResult.PipingDesignResults.Wti2017UpliftHcritical = designResult.PipingDesignResults.Wbi2017UpliftHcritical;

            if (designResult.PipingDesignResults.Wbi2017DeltaPhiCuSpecified) desResult.PipingDesignResults.Wti2017UpliftDeltaPhiC = designResult.PipingDesignResults.Wbi2017DeltaPhiCu;

            if (designResult.PipingDesignResults.Wbi2017HeaveFactorSpecified) desResult.PipingDesignResults.Wti2017HeaveSafetyFactor = designResult.PipingDesignResults.Wbi2017HeaveFactor;

            if (designResult.PipingDesignResults.Wbi2017HeaveHcriticalSpecified) desResult.PipingDesignResults.Wti2017HeaveHcritical = designResult.PipingDesignResults.Wbi2017HeaveHcritical;

            if (designResult.PipingDesignResults.Wbi2017GradientSpecified) desResult.PipingDesignResults.Wti2017Gradient = designResult.PipingDesignResults.Wbi2017Gradient;

            if (designResult.PipingDesignResults.Wbi2017FactorOverallSpecified) desResult.PipingDesignResults.Wti2017SafetyFactorOverall = designResult.PipingDesignResults.Wbi2017FactorOverall;

            if (designResult.PipingDesignResults.Wbi2017HcriticalOverallSpecified) desResult.PipingDesignResults.Wti2017HcriticalOverall = designResult.PipingDesignResults.Wbi2017HcriticalOverall;

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

            if (designResult.PipingDesignResults.Wbi2017EffectiveStressSpecified) desResult.PipingDesignResults.EffectiveStress = designResult.PipingDesignResults.Wbi2017EffectiveStress;

            if (designResult.PipingDesignResults.Wbi2017CCreepSpecified) desResult.PipingDesignResults.CCreep = designResult.PipingDesignResults.Wbi2017CCreep;

            if (designResult.PipingDesignResults.UpliftSituation != null)
            {
                var 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 (int j = 0; j < inputSurfaceLine.Points.Length; j++)
            {
                var inputPoint = inputSurfaceLine.Points[j];
                var geometryPoint = new GeometryPoint()
                {
                    X = inputPoint.X,
                    Y = 0.0,
                    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.Zone1SafetyFactorSpecified) desResult.StabilityDesignResults.Zone1SafetyFactor = designResult.StabilityDesignResults.Zone1SafetyFactor;

            if (designResult.StabilityDesignResults.Zone1EntryPointXSpecified) desResult.StabilityDesignResults.LocalZone1EntryPointX = designResult.StabilityDesignResults.Zone1EntryPointX;

            if (designResult.StabilityDesignResults.Zone1ExitPointXSpecified) desResult.StabilityDesignResults.LocalZone1ExitPointX = designResult.StabilityDesignResults.Zone1ExitPointX;

            if (designResult.StabilityDesignResults.Zone2SafetyFactorSpecified) desResult.StabilityDesignResults.Zone2SafetyFactor = designResult.StabilityDesignResults.Zone2SafetyFactor;

            if (designResult.StabilityDesignResults.Zone2EntryPointXSpecified) desResult.StabilityDesignResults.LocalZone2EntryPointX = designResult.StabilityDesignResults.Zone2EntryPointX;

            if (designResult.StabilityDesignResults.Zone2ExitPointXSpecified) desResult.StabilityDesignResults.LocalZone2ExitPointX = designResult.StabilityDesignResults.Zone2ExitPointX;

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

            if (designResult.StabilityDesignResults.UpliftSituation != null)
            {
                var 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);
            }
        }

        private static void CreateLocationResultsOutput(Output output, DamProjectData damProjectData)
        {
            // Calculation results (per location)
            damProjectData.LocationJobs = new List<LocationJob>();
            foreach (var outputLocationResult in output.Results.CalculationResults.LocationResults)
            {
                var locationJob = new LocationJob(null)
                {
                    LocationResult = new LocationResult()
                };

                Location location = null;
                if (outputLocationResult.RegionalScenariosResult != null)
                {
                    locationJob.LocationResult.RegionalScenariosResult = new RegionalScenariosResult
                    {
                        CalculationResult = ConversionHelper.ConvertToCalculationResult(outputLocationResult.RegionalScenariosResult.CalculationResult),
                        SafetyFactor = outputLocationResult.RegionalScenariosResult.SafetyFactor
                    };
                    var regionalScenarioResults = new List<Data.RegionalAssessmentResults.RegionalScenarioResult>();
                    foreach (var outPutRegionalScenarioResult in outputLocationResult.RegionalScenariosResult.RegionalScenarioResult)
                    {
                        var regionalScenarioResult = new Data.RegionalAssessmentResults.RegionalScenarioResult
                        {
                            CalculationResult = ConversionHelper.ConvertToCalculationResult(outPutRegionalScenarioResult.CalculationResult),
                            DikeDrySensitivity = ConversionHelper.ConvertToDikeDrySensitivity(outPutRegionalScenarioResult.DikeDrySensitivity),
                            HydraulicShortcutType = ConversionHelper.ConvertToHydraulicShortcutType(outPutRegionalScenarioResult.HydraulicShortcutType),
                            LoadSituation = ConversionHelper.ConvertToLoadSituation(outPutRegionalScenarioResult.LoadSituation),
                            ModelOption = ConversionHelper.ConvertToMStabModelType(outPutRegionalScenarioResult.ModelOption),
                            SafetyFactor = outPutRegionalScenarioResult.SafetyFactor,
                            ScenarioType = ConversionHelper.ConvertToScenarioType(outPutRegionalScenarioResult.ScenarioType),
                            UpliftType = ConversionHelper.ConvertToUpliftType(outPutRegionalScenarioResult.UpliftType)
                        };
                        var regionalScenarioProfileResults = new List<RegionalScenarioProfileJob>();
                        foreach (var outPutRegionalScenarioProfileResult in outPutRegionalScenarioResult.RegionalScenarioProfileResults)
                        {
                            
                            var locationName = outPutRegionalScenarioProfileResult.LocationName;
                            location = damProjectData.Dike.Locations.FirstOrDefault(x => x.Name == locationName);                                
                            var spName = outPutRegionalScenarioProfileResult.SoilProfileName;
                            var soilGeometryProbability = location.Segment.SoilProfileProbabilities.FirstOrDefault(s => ((s.SegmentFailureMechanismType == null) ||
                                                                                                                            (s.SegmentFailureMechanismType.Value == FailureMechanismSystemType.StabilityInside)) &&
                                                                                                                        (s.SoilProfile1DName == spName));
                            var regionalScenarioProfileResult = new RegionalScenarioProfileJob(location, soilGeometryProbability)
                            {
                                LoadSituation = ConversionHelper.ConvertToLoadSituation(outPutRegionalScenarioProfileResult.LoadSituation),
                                DikeDrySensitivity = ConversionHelper.ConvertToDikeDrySensitivity(outPutRegionalScenarioProfileResult.DikeDrySensitivity),
                                HydraulicShortcutType = ConversionHelper.ConvertToHydraulicShortcutType(outPutRegionalScenarioProfileResult.HydraulicShortcutType),
                                UpliftType = ConversionHelper.ConvertToUpliftType(outPutRegionalScenarioProfileResult.UpliftType),
                                MstabModelOption = ConversionHelper.ConvertToMStabModelType(outPutRegionalScenarioProfileResult.MStabModelOption),
                                PipingModelOption = ConversionHelper.ConvertToPipingModelType(outPutRegionalScenarioProfileResult.PipingModelOption),
                                ScenarioType = ConversionHelper.ConvertToScenarioType(outPutRegionalScenarioProfileResult.ScenarioType),
                                FailureMechanismType = ConversionHelper.ConvertToFailureMechanismSystemType(outPutRegionalScenarioProfileResult.FailureMechanismType),
                                BaseFileName = outPutRegionalScenarioProfileResult.BaseFileName,
                                RegionalResultType = ConversionHelper.ConvertToRegionalResultType(outPutRegionalScenarioProfileResult.RegionalResult.RegionalResultType),
                                SafetyFactor = outPutRegionalScenarioProfileResult.RegionalResult.SafetyFactor,
                                ProbabilityOfFailure = outPutRegionalScenarioProfileResult.RegionalResult.ProbabilityOfFailure,
                                CalculationResult = ConversionHelper.ConvertToCalculationResult(outPutRegionalScenarioProfileResult.RegionalResult.CalculationResult)
                            };
                            regionalScenarioProfileResults.Add(regionalScenarioProfileResult);                            
                        }
                        regionalScenarioResult.RegionalScenarioProfileResults.AddRange(regionalScenarioProfileResults);
                        regionalScenarioResults.Add(regionalScenarioResult);                        
                    }                    
                    locationJob.LocationResult.RegionalScenariosResult.RegionalScenarioResults.AddRange(regionalScenarioResults);
                }
                locationJob.Location = location;
                damProjectData.LocationJobs.Add(locationJob);
            }
        }
    }
}