// 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 Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Io.XmlOutput;

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();

            // Validation will be done using a static logmanager and passing logmessages. But this has still to be implemented.
            // Validation using Attributes must be removed, using explicit validation methods (ValidatioResult) replaced. Still to be done.
            output.ValidationResults = new Message[0];
            //            var mestel = 0;
            //            foreach (var res in valres)
            //            {
            //                var mes = new Message();
            //                mes.Message1 = res.Text;
            //                mes.MessageType = res.MessageType;
            //                output.ValidationResults[mestel] = mes;
            //                mestel++;
            //            }

            // Results
            output.Results = new OutputResults();
            // Calculation messages
            output.Results.CalculationMessages = new Message[0]; // Were do these come from?
            // Actual results
            output.Results.CalculationResults = new CalculationResults();

            CreateDesignResultsOutput(damProjectData, output);
            CreateLocationResultsOutput(damProjectData, output);
            return output;
        }

        private static void CreateDesignResultsOutput(DamProjectData damProjectData, Output output)
        {
            // Design results
            var designResults = damProjectData.DesignCalculations;
            if (designResults.Count > 0)
            {
                output.Results.CalculationResults.DesignResults = 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,
                    };

                    desResult.CalculationResult = ConversionHelper.ConvertToOutputCalculationResult(designResult.CalculationResult);

                    if (designResult.PipingDesignResults != null)
                    {
                        CreateDesignResultsPipingOutput(desResult, designResult);
                    }
                    if (designResult.StabilityDesignResults != null)
                    {
                        CreateDesignResultsStabilityOutput(desResult, designResult);
                    }
                    output.Results.CalculationResults.DesignResults[designResultCount] = desResult;
                    designResultCount++;
                }
            }
            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();
                    message.MessageType = ConversionHelper.ConvertToInputMessageType(calculationMessages[i].MessageType);
                    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();
                desResult.PipingDesignResults.RedesignedSurfaceLine.Name = designResult.PipingDesignResults.RedesignedSurfaceLine.Name;
                desResult.PipingDesignResults.RedesignedSurfaceLine.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.Wbi2017FactorSpecified = designResult.PipingDesignResults.Wti2017Factor.HasValue;
            if (designResult.PipingDesignResults.Wti2017Factor.HasValue) desResult.PipingDesignResults.Wbi2017Factor = designResult.PipingDesignResults.Wti2017Factor.Value;

            desResult.PipingDesignResults.Wbi2017HcriticalSpecified = designResult.PipingDesignResults.Wti2017Hcritical.HasValue;
            if (designResult.PipingDesignResults.Wti2017Hcritical.HasValue) desResult.PipingDesignResults.Wbi2017Hcritical = designResult.PipingDesignResults.Wti2017Hcritical.Value;

            desResult.PipingDesignResults.ExitPointXSpecified = designResult.PipingDesignResults.LocalExitPointX.HasValue;
            if (designResult.PipingDesignResults.LocalExitPointX.HasValue) desResult.PipingDesignResults.ExitPointX = designResult.PipingDesignResults.LocalExitPointX.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;
                }
            }

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

            desResult.StabilityDesignResults.Zone1SafetyFactorSpecified = designResult.StabilityDesignResults.Zone1SafetyFactor.HasValue;
            if (designResult.StabilityDesignResults.Zone1SafetyFactor.HasValue) desResult.StabilityDesignResults.Zone1SafetyFactor = designResult.StabilityDesignResults.Zone1SafetyFactor.Value;

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

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

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

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

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

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

        private static void CreateLocationResultsOutput(DamProjectData damProjectData, Output output)
        {
            // Calculation results (per location)
            output.Results.CalculationResults.LocationResults = new CalculationResultsLocationResult[damProjectData.LocationJobs.Count];
            var jobtel = 0;
            foreach (var locationJob in damProjectData.LocationJobs)
            {
                var outputLocationResult = new CalculationResultsLocationResult();

                // Stability TimeSerie (later)

                // Piping TimeSerie (later)

                // RegionalScenarios results
                outputLocationResult.RegionalScenariosResult = new CalculationResultsLocationResultRegionalScenariosResult();
                outputLocationResult.RegionalScenariosResult.SafetyFactor = locationJob.LocationResult.RegionalScenariosResult.SafetyFactor;
                outputLocationResult.RegionalScenariosResult.CalculationResult = ConversionHelper.ConvertToOutputCalculationResult(locationJob.LocationResult.RegionalScenariosResult.CalculationResult);
                outputLocationResult.RegionalScenariosResult.RegionalScenarioResult = new RegionalScenarioResult[locationJob.LocationResult.RegionalScenariosResult.RegionalScenarioResults.Count];
                var scentel = 0;
                foreach (var rwScenarioResult in locationJob.LocationResult.RegionalScenariosResult.RegionalScenarioResults)
                {
                    var outputRwScenarioResult = new RegionalScenarioResult();
                    outputRwScenarioResult.LoadSituation = ConversionHelper.ConvertToOutputLoadSituation(rwScenarioResult.LoadSituation);
                    outputRwScenarioResult.DikeDrySensitivity = ConversionHelper.ConvertToOutputDikeDrySensitivity(rwScenarioResult.DikeDrySensitivity);
                    outputRwScenarioResult.HydraulicShortcutType = ConversionHelper.ConvertToOutputHydraulicShortcutType(rwScenarioResult.HydraulicShortcutType);
                    outputRwScenarioResult.UpliftType = ConversionHelper.ConvertToOutputUpliftType(rwScenarioResult.UpliftType);
                    outputRwScenarioResult.ModelOption = ConversionHelper.ConvertToOutputMStabModelType(rwScenarioResult.ModelOption);
                    outputRwScenarioResult.ScenarioType = ConversionHelper.ConvertToOutputScenarioType(rwScenarioResult.ScenarioType);
                    outputRwScenarioResult.CalculationResult = ConversionHelper.ConvertToOutputCalculationResult(rwScenarioResult.CalculationResult);
                    outputRwScenarioResult.SafetyFactor = rwScenarioResult.SafetyFactor;
                    outputRwScenarioResult.RegionalScenarioProfileResults = new RegionalScenarioResultRegionalScenarioProfileResult[rwScenarioResult.RegionalScenarioProfileResults.Count];
                    var proftel = 0;
                    foreach (var profileResult in rwScenarioResult.RegionalScenarioProfileResults)
                    {
                        var outputProfileResult = new RegionalScenarioResultRegionalScenarioProfileResult();
                        outputProfileResult.LocationName = profileResult.LocationName;
                        outputProfileResult.LoadSituation = ConversionHelper.ConvertToOutputLoadSituation(profileResult.LoadSituation);
                        outputProfileResult.DikeDrySensitivity = ConversionHelper.ConvertToOutputDikeDrySensitivity(profileResult.DikeDrySensitivity);
                        outputProfileResult.HydraulicShortcutType = ConversionHelper.ConvertToOutputHydraulicShortcutType(profileResult.HydraulicShortcutType);
                        outputProfileResult.UpliftType = ConversionHelper.ConvertToOutputUpliftType(profileResult.UpliftType);
                        outputProfileResult.MStabModelOption = ConversionHelper.ConvertToOutputMStabModelType(profileResult.MstabModelOption);
                        outputProfileResult.PipingModelOption = ConversionHelper.ConvertToOutputPipingModelType(profileResult.PipingModelOption);
                        outputProfileResult.ScenarioType = ConversionHelper.ConvertToOutputScenarioType(profileResult.ScenarioType);
                        outputProfileResult.SoilProfileName = profileResult.SoilProfileName;
                        outputProfileResult.SoilProfileProbability = profileResult.SoilProfileProbability;
                        outputProfileResult.FailureMechanismType = ConversionHelper.ConvertToInputFailureMechanismSystemType(profileResult.FailureMechanismType);
                        outputProfileResult.BaseFileName = profileResult.BaseFileName;
                        outputProfileResult.RegionalResult = new RegionalResult();
                        outputProfileResult.RegionalResult.RegionalResultType = ConversionHelper.ConvertToOutputRegionalResultType(profileResult.RegionalResultType);
                        outputProfileResult.RegionalResult.SafetyFactor = profileResult.SafetyFactor;
                        outputProfileResult.RegionalResult.ProbabilityOfFailure = profileResult.ProbabilityOfFailure;
                        outputProfileResult.RegionalResult.CalculationResult = ConversionHelper.ConvertToOutputCalculationResult(profileResult.CalculationResult);
                        outputLocationResult.RegionalScenariosResult.RegionalScenarioResult[scentel].RegionalScenarioProfileResults[proftel] = outputProfileResult;
                        proftel++;
                    }
                    outputLocationResult.RegionalScenariosResult.RegionalScenarioResult[scentel] = outputRwScenarioResult;
                    scentel++;

                    // RWSchematizationFactors Result later
                    // Note that xsd should be adapted first: the types should be stored as int, not as string! This to be able to reuse the converters
//                    outputLocationResult.RegionalSchematizationFactorsResult = new CalculationResultsLocationResultRegionalSchematizationFactorsResult();
//                    outputLocationResult.RegionalSchematizationFactorsResult.RegionalSchematizationFactorResult = new CalculationResultsLocationResultRegionalSchematizationFactorsResultRegionalSchematizationFactorResult[damProjectData.SchematizationFactors.Count];
//                    var factortel = 0;
//                    foreach (var rwSchematizationFactorResult in damProjectData.SchematizationFactors)
//                    {
//                        var factorResult = new CalculationResultsLocationResultRegionalSchematizationFactorsResultRegionalSchematizationFactorResult();
//                        factorResult.LocationName = rwSchematizationFactorResult.LocationName;
//                        factorResult.SchematizationType = rwSchematizationFactorResult.SchematizationType;
//                        factorResult.SoilProfileName = rwSchematizationFactorResult.SoilProfileName;
//                        factorResult.OriginalDecisiveSoilProfileName = rwSchematizationFactorResult.OriginalDecisiveSoilProfileName;
//                        factorResult.SchematizationFactor = rwSchematizationFactorResult.SchematizationFactor;
//                        factorResult.SummedProfileProbability = rwSchematizationFactorResult.SummedProfileProbability;
//                        factorResult.DecisiveRegionalScenarioName = rwSchematizationFactorResult.DecisiveScenarioName;
//                        factorResult.DetrimentFactor = rwSchematizationFactorResult.DetrimentFactor;
//                        factorResult.SafetyFactor = rwSchematizationFactorResult.SafetyFactor;
//                        factorResult.CalculationResult = ConversionHelper.ConvertToOutputCalculationResult(rwSchematizationFactorResult.CalculationResult);
//                        outputLocationResult.RegionalSchematizationFactorsResult.RegionalSchematizationFactorResult[factortel] = factorResult;
//                        factortel++;
//                    }

                }
                output.Results.CalculationResults.LocationResults[jobtel] = outputLocationResult;
                jobtel++;
            }
        }
    }
}