// 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 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.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 != null)
                {
                    CreateDesignResultsOutput(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.Length; i++)
            {
                var 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 (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.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.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.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)
            {
                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);
            }
        }        
    }
}