// 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.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],
                    // Actual results
                    CalculationResults = new CalculationResults()
                }
            };
            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.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,
                        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++;
                }
            }
        }

        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.Wbi2017BackwardErosionFactorSpecified = designResult.PipingDesignResults.Wti2017BackwardErosionSafetyFactor.HasValue;
            if (designResult.PipingDesignResults.Wti2017BackwardErosionSafetyFactor.HasValue) desResult.PipingDesignResults.Wbi2017BackwardErosionFactor = designResult.PipingDesignResults.Wti2017BackwardErosionSafetyFactor.Value;

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

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

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

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

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

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

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

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

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

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

            desResult.PipingDesignResults.Wbi2017HcriticalOverallSpecified = designResult.PipingDesignResults.Wti2017HcriticalOverall.HasValue;
            if (designResult.PipingDesignResults.Wti2017HcriticalOverall.HasValue) desResult.PipingDesignResults.Wbi2017HcriticalOverall = 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.Wbi2017EffectiveStressSpecified = designResult.PipingDesignResults.EffectiveStress.HasValue;
            if (designResult.PipingDesignResults.EffectiveStress.HasValue) desResult.PipingDesignResults.Wbi2017EffectiveStress = designResult.PipingDesignResults.EffectiveStress.Value;

            desResult.PipingDesignResults.Wbi2017CCreepSpecified = designResult.PipingDesignResults.CCreep.HasValue;
            if (designResult.PipingDesignResults.CCreep.HasValue) desResult.PipingDesignResults.Wbi2017CCreep = 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;
                }
            }

            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;

            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];
            var jobtel = 0;
            foreach (var locationJob in damProjectData.LocationJobs)
            {
                var outputLocationResult = new CalculationResultsLocationResult
                {
                    // RegionalScenarios results
                    RegionalScenariosResult = new CalculationResultsLocationResultRegionalScenariosResult()
                };

                if (locationJob.LocationResult.RegionalScenariosResult != null)
                {
                    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 regionalScenarioResult in locationJob.LocationResult.RegionalScenariosResult.RegionalScenarioResults)
                    {
                        var outputRegionalScenarioResult = new RegionalScenarioResult
                        {
                            LoadSituation = ConversionHelper.ConvertToOutputLoadSituation(regionalScenarioResult.LoadSituation),
                            DikeDrySensitivity = ConversionHelper.ConvertToOutputDikeDrySensitivity(regionalScenarioResult.DikeDrySensitivity),
                            HydraulicShortcutType = ConversionHelper.ConvertToOutputHydraulicShortcutType(regionalScenarioResult.HydraulicShortcutType),
                            UpliftType = ConversionHelper.ConvertToOutputUpliftType(regionalScenarioResult.UpliftType),
                            ModelOption = ConversionHelper.ConvertToOutputMStabModelType(regionalScenarioResult.ModelOption),
                            ScenarioType = ConversionHelper.ConvertToOutputScenarioType(regionalScenarioResult.ScenarioType),
                            CalculationResult = ConversionHelper.ConvertToOutputCalculationResult(regionalScenarioResult.CalculationResult),
                            SafetyFactor = regionalScenarioResult.SafetyFactor,
                            RegionalScenarioProfileResults = new RegionalScenarioResultRegionalScenarioProfileResult[regionalScenarioResult.RegionalScenarioProfileResults.Count]
                        };
                        var proftel = 0;
                        foreach (var profileResult in regionalScenarioResult.RegionalScenarioProfileResults)
                        {
                            var outputProfileResult = new RegionalScenarioResultRegionalScenarioProfileResult
                            {
                                LocationName = profileResult.LocationName,
                                LoadSituation = ConversionHelper.ConvertToOutputLoadSituation(profileResult.LoadSituation),
                                DikeDrySensitivity = ConversionHelper.ConvertToOutputDikeDrySensitivity(profileResult.DikeDrySensitivity),
                                HydraulicShortcutType = ConversionHelper.ConvertToOutputHydraulicShortcutType(profileResult.HydraulicShortcutType),
                                UpliftType = ConversionHelper.ConvertToOutputUpliftType(profileResult.UpliftType),
                                MStabModelOption = ConversionHelper.ConvertToOutputMStabModelType(profileResult.MstabModelOption),
                                PipingModelOption = ConversionHelper.ConvertToOutputPipingModelType(profileResult.PipingModelOption),
                                ScenarioType = ConversionHelper.ConvertToOutputScenarioType(profileResult.ScenarioType),
                                SoilProfileName = profileResult.SoilProfileName,
                                SoilProfileProbability = profileResult.SoilProfileProbability,
                                FailureMechanismType = ConversionHelper.ConvertToInputFailureMechanismSystemType(profileResult.FailureMechanismType),
                                BaseFileName = profileResult.BaseFileName,
                                RegionalResult = new RegionalResult
                                {
                                    RegionalResultType = ConversionHelper.ConvertToOutputRegionalResultType(profileResult.RegionalResultType),
                                    SafetyFactor = profileResult.SafetyFactor,
                                    ProbabilityOfFailure = profileResult.ProbabilityOfFailure,
                                    CalculationResult = ConversionHelper.ConvertToOutputCalculationResult(profileResult.CalculationResult)
                                }
                            };
                            outputRegionalScenarioResult.RegionalScenarioProfileResults[proftel] = outputProfileResult;
                            proftel++;
                        }
                        outputLocationResult.RegionalScenariosResult.RegionalScenarioResult[scentel] = outputRegionalScenarioResult;
                        scentel++;
                    }
                    output.Results.CalculationResults.LocationResults[jobtel] = outputLocationResult;
                    jobtel++;
                }
            }
            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++;
            }
        }
    }
}