// Copyright (C) Stichting Deltares 2017. All rights reserved.
//
// This file is part of the application DAM - UI.
//
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
//
// You should have received a copy of the GNU 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;
using System.Collections.Generic;
using System.Linq;
using Deltares.DamEngine.Io.XmlInput;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard.Extensions;
using Soil = Deltares.Geotechnics.Soils.Soil;
using SoilProfile1D = Deltares.Geotechnics.Soils.SoilProfile1D;
using SurfaceLine = Deltares.DamEngine.Io.XmlInput.SurfaceLine;

namespace Deltares.Dam.Data.DamEngineIo
{
    /// <summary>
    /// Create DAM UI project from XML Input object
    /// </summary>
    public class FillDamUiFromXmlInput
    {
        /// <summary>
        /// Creates the dam project data.
        /// </summary>
        /// <param name="input">The input.</param>
        /// <returns></returns>
        public static DamProjectData CreateDamProjectData(Input input)
        {
            ValidateInput(input);
            var damProjectData = new DamProjectData();

            damProjectData.WaterBoard = new WaterBoard();
            damProjectData.WaterBoard.Dikes = new List<Dike>();
            damProjectData.WaterBoard.Dikes.Add(new Dike());
            Dike dike = damProjectData.WaterBoard.Dikes[0];

            TransferAnalysisSpecification(input, damProjectData);
            TransferStabilityParameters(input, damProjectData);

            var localSurfaceLines = new List<SurfaceLine2>();
            TransferSurfaceLines(input.SurfaceLines, localSurfaceLines);
            dike.SoilList = new SoilList();
            TransferSoils(input.Soils, dike.SoilList);
            TransferSoilProfiles1D(input.SoilProfiles1D, dike.SoilProfiles, dike.SoilList);
            TransferSegments(input.Segments, dike.SoilProfiles, damProjectData.WaterBoard.Segments);
            TransferLocations(input.Locations, dike.Locations, localSurfaceLines, damProjectData.WaterBoard.Segments);
            return damProjectData;
        }

        private static void TransferAnalysisSpecification(Input input, DamProjectData damProjectData)
        {
            damProjectData.DamProjectType = ConversionHelper.ConvertToDamProjectType(input.DamProjectType);

            var calculationSpecification = new DamFailureMechanismeCalculationSpecification();

            calculationSpecification.FailureMechanismSystemType = ConversionHelper.ConvertToFailureMechanismSystemType(input.FailureMechanismSystemType);

            if (input.AnalysisTypeSpecified)
            {
                DamProjectCalculationSpecification.SelectedAnalysisType = ConversionHelper.ConvertToAnalysisType(input.AnalysisType);
            }

            if (input.PipingModelTypeSpecified)
            {
                calculationSpecification.PipingModelType = ConversionHelper.ConvertToPipingModelType(input.PipingModelType);
            }

            if (input.StabilityModelTypeSpecified)
            {
                calculationSpecification.StabilityModelType = ConversionHelper.ConvertToStabilityModelType(input.StabilityModelType);
            }
            damProjectData.DamProjectCalculationSpecification.DamCalculationSpecifications.Add(calculationSpecification);
        }

        private static void TransferStabilityParameters(Input input, DamProjectData damProjectData)
        {
            if (input.StabilityParameters != null)
            {
                var curSpec = damProjectData.DamProjectCalculationSpecification.CurrentSpecification;
                if (curSpec != null)
                {
                    curSpec.FailureMechanismeParamatersMStab = new FailureMechanismeParamatersMStab();
                    curSpec.FailureMechanismeParamatersMStab.MStabParameters = new MStabParameters();
                    var curStabParamas = curSpec.FailureMechanismeParamatersMStab.MStabParameters;
                    curStabParamas.SearchMethod = ConversionHelper.ConvertToSearchMethod(input.StabilityParameters.SearchMethod);
                    curStabParamas.SlipCircleDefinition = new SlipCircleDefinition();
                    var slipCircleDefinition = curStabParamas.SlipCircleDefinition;
                    slipCircleDefinition.GridSizeDetermination = ConversionHelper.ConvertToGridDetermination(input.StabilityParameters.GridDetermination);

                    if (input.StabilityParameters.BishopTangentLinesDefinitionSpecified)
                    {
                        slipCircleDefinition.BishopTangentLinesDefinition = ConversionHelper.ConvertToTangentLinesDefinition(input.StabilityParameters.BishopTangentLinesDefinition);
                    }
                    if (input.StabilityParameters.BishopTangentLinesDistanceSpecified)
                    {
                        slipCircleDefinition.BishopTangentLinesDistance = input.StabilityParameters.BishopTangentLinesDistance;
                    }
                    if (input.StabilityParameters.BishopGridVerticalPointsCountSpecified)
                    {
                        slipCircleDefinition.BishopGridVerticalPointCount = input.StabilityParameters.BishopGridVerticalPointsCount;
                    }
                    if (input.StabilityParameters.BishopGridVerticalPointsDistanceSpecified)
                    {
                        slipCircleDefinition.BishopGridVerticalPointDistance = input.StabilityParameters.BishopGridVerticalPointsDistance;
                    }
                    if (input.StabilityParameters.BishopGridHorizontalPointsCountSpecified)
                    {
                        slipCircleDefinition.BishopGridHorizontalPointCount = input.StabilityParameters.BishopGridHorizontalPointsCount;
                    }
                    if (input.StabilityParameters.BishopGridHorizontalPointsDistanceSpecified)
                    {
                        slipCircleDefinition.BishopGridHorizontalPointDistance = input.StabilityParameters.BishopGridHorizontalPointsDistance;
                    }
                    if (input.StabilityParameters.UpliftVanTangentLinesDefinitionSpecified)
                    {
                        slipCircleDefinition.UpliftVanTangentLinesDefinition = ConversionHelper.ConvertToTangentLinesDefinition(input.StabilityParameters.UpliftVanTangentLinesDefinition);
                    }
                    if (input.StabilityParameters.UpliftVanTangentLinesDistanceSpecified)
                    {
                        slipCircleDefinition.UpliftVanTangentLinesDistance = input.StabilityParameters.UpliftVanTangentLinesDistance;
                    }
                    if (input.StabilityParameters.UpliftVanGridLeftVerticalPointsCountSpecified)
                    {
                        slipCircleDefinition.UpliftVanLeftGridVerticalPointCount = input.StabilityParameters.UpliftVanGridLeftVerticalPointsCount;
                    }
                    if (input.StabilityParameters.UpliftVanGridLeftVerticalPointsDistanceSpecified)
                    {
                        slipCircleDefinition.UpliftVanLeftGridVerticalPointDistance = input.StabilityParameters.UpliftVanGridLeftVerticalPointsDistance;
                    }
                    if (input.StabilityParameters.UpliftVanGridLeftHorizontalPointsCountSpecified)
                    {
                        slipCircleDefinition.UpliftVanLeftGridHorizontalPointCount = input.StabilityParameters.UpliftVanGridLeftHorizontalPointsCount;
                    }
                    if (input.StabilityParameters.UpliftVanGridLeftHorizontalPointsDistanceSpecified)
                    {
                        slipCircleDefinition.UpliftVanLeftGridHorizontalPointDistance = input.StabilityParameters.UpliftVanGridLeftHorizontalPointsDistance;
                    }
                    if (input.StabilityParameters.UpliftVanGridRightVerticalPointsCountSpecified)
                    {
                        slipCircleDefinition.UpliftVanRightGridVerticalPointCount = input.StabilityParameters.UpliftVanGridRightVerticalPointsCount;
                    }
                    if (input.StabilityParameters.UpliftVanGridRightVerticalPointsDistanceSpecified)
                    {
                        slipCircleDefinition.UpliftVanRightGridVerticalPointDistance = input.StabilityParameters.UpliftVanGridRightVerticalPointsDistance;
                    }
                    if (input.StabilityParameters.UpliftVanGridRightHorizontalPointsCountSpecified)
                    {
                        slipCircleDefinition.UpliftVanRightGridHorizontalPointCount = input.StabilityParameters.UpliftVanGridRightHorizontalPointsCount;
                    }
                    if (input.StabilityParameters.UpliftVanGridRightHorizontalPointsDistanceSpecified)
                    {
                        slipCircleDefinition.UpliftVanRightGridHorizontalPointDistance = input.StabilityParameters.UpliftVanGridRightHorizontalPointsDistance;
                    }
                }
            }
        }

        private static void ValidateInput(Input input)
        {
            if (input == null)
            {
                throw new NullReferenceException("No input defined");
            }
            if (input.Locations == null)
            {
                throw new NullReferenceException("No locations defined in the input");
            }
            foreach (DamEngine.Io.XmlInput.Location location in input.Locations)
            {
                if (location.DesignScenarios == null)
                {
                    throw new NullReferenceException("No design scenarios defined in location");
                }
            }
            if (input.SurfaceLines == null)
            {
                throw new NullReferenceException("No surfacelines defined in the input");
            }
            else
            {
                foreach (var surfaceLine in input.SurfaceLines)
                {
                    if ((surfaceLine.Points == null) || (surfaceLine.Points.Length < 1))
                    {
                        throw new NullReferenceException(string.Format("Surfaceline '{0}' has no points", surfaceLine.Name));
                    }
                }
            }
            if (input.Soils == null)
            {
                throw new NullReferenceException("No soils defined in the input");
            }
        }

        private static void TransferSoils(DamEngine.Io.XmlInput.Soil[] inputSoils, SoilList dikeSoilList)
        {
            var soils = dikeSoilList.Soils;
            for (int i = 0; i < inputSoils.Length; i++)
            {
                var soil = new Soil();
                var inputSoil = inputSoils[i];
                soil.Name = inputSoil.Name;
                soil.AbovePhreaticLevel = inputSoil.AbovePhreaticLevelSpecified ? inputSoil.AbovePhreaticLevel : Double.NaN;
                soil.BelowPhreaticLevel = inputSoil.BelowPhreaticLevelSpecified ? inputSoil.BelowPhreaticLevel : Double.NaN;
                soil.DryUnitWeight = inputSoil.DryUnitWeightSpecified ? inputSoil.DryUnitWeight : Double.NaN;
                soil.BeddingAngle = inputSoil.BeddingAngleSpecified ? inputSoil.BeddingAngle : Double.NaN;
                soil.DiameterD70 = inputSoil.DiameterD70Specified ? inputSoil.DiameterD70 : Double.NaN;
                soil.DiameterD90 = inputSoil.DiameterD90Specified ? inputSoil.DiameterD90 : Double.NaN;
                soil.PermeabKx = inputSoil.PermeabKxSpecified ? inputSoil.PermeabKx : Double.NaN;
                soil.WhitesConstant = inputSoil.WhitesConstantSpecified ? inputSoil.WhitesConstant : Double.NaN;
                soils.Add(soil);
            }
        }

        private static void TransferSurfaceLines(SurfaceLine[] inputSurfaceLines, IList<SurfaceLine2> dikeSurfaceLines)
        {
            for (int i = 0; i < inputSurfaceLines.Length; i++)
            {
                var inputSurfaceLine = inputSurfaceLines[i];
                var surfaceLine = FillDamUiFromXmlHelper.ConvertXmlSurfaceLineToSurfaceLine2(inputSurfaceLine);
                dikeSurfaceLines.Add(surfaceLine);
            }
        }

        private static void TransferLocations(DamEngine.Io.XmlInput.Location[] inputLocations, IList<Location> dikeLocations, IList<SurfaceLine2> dikeSurfaceLines, IList<Segment> segments)
        {
            for (int i = 0; i < inputLocations.Length; i++)
            {
                var location = new Location();
                var inputLocation = inputLocations[i];
                var waternetOptions = inputLocation.WaternetOptions;
                location.Name= inputLocation.Name;
                location.PLLineCreationMethod = ConversionHelper.ConvertToPhreaticLineCreationMethod(waternetOptions.PhreaticLineCreationMethod);
                location.IntrusionVerticalWaterPressure = ConversionHelper.ConvertToIntrusionVerticalWaterPressure(waternetOptions.IntrusionVerticalWaterPressure);
                location.PolderLevel = waternetOptions.PolderLevel;
                location.DampingFactorPL4 = waternetOptions.DampingFactorPL3;
                location.DampingFactorPL3 = waternetOptions.DampingFactorPL4;
                location.PenetrationLength = waternetOptions.PenetrationLength;
                location.PlLineOffsetBelowDikeCrestMiddle = (waternetOptions.Pl1BelowCrestMiddleSpecified ? (double?) waternetOptions.Pl1BelowCrestMiddle : null);
                location.UsePlLineOffsetFactorBelowShoulderCrest = waternetOptions.Pl1FactorBelowShoulderCrestSpecified;
                location.PlLineOffsetFactorBelowShoulderCrest = waternetOptions.Pl1FactorBelowShoulderCrest;
                location.PlLineOffsetDryBelowDikeCrestMiddle = (waternetOptions.DryPl1BelowCrestMiddleSpecified ? (double?) waternetOptions.DryPl1BelowCrestMiddle : null);
                location.UsePlLineOffsetDryFactorBelowShoulderCrest = waternetOptions.DryPl1FactorBelowShoulderCrestSpecified;
                location.PlLineOffsetDryFactorBelowShoulderCrest = waternetOptions.DryPl1FactorBelowShoulderCrest;
                location.HeadPL2 = (waternetOptions.HeadPl2Specified ? (double?) waternetOptions.HeadPl2 : null);
                location.HeadPl3 = (waternetOptions.HeadPl3Specified ? (double?) waternetOptions.HeadPl3 : null);
                location.HeadPl4 = (waternetOptions.HeadPl4Specified ? (double?) waternetOptions.HeadPl4 : null);
                location.SlopeDampingPiezometricHeightPolderSide = waternetOptions.SlopeDampingFactor;
                location.PlLineOffsetBelowDikeTopAtRiver = waternetOptions.Pl1BelowCrestRiverside;
                location.PlLineOffsetBelowDikeTopAtPolder = waternetOptions.Pl1BelowCrestPolderside;
                location.PlLineOffsetBelowShoulderBaseInside = waternetOptions.Pl1BelowShoulderCrestPolderside;
                location.PlLineOffsetBelowDikeToeAtPolder = waternetOptions.Pl1BelowToeDikePolderside;

                SurfaceLine2 surfaceLine = dikeSurfaceLines.First(n => n.Name.Equals(inputLocation.SurfaceLineName));
                location.LocalXZSurfaceLine2 = surfaceLine;

                Segment segment = segments.First(s => s.Name.Equals(inputLocation.SegmentName));
                location.Segment = segment;

                if (inputLocation.DesignScenarios != null)
                {
                    for (int j = 0; j < inputLocation.DesignScenarios.Length; j++)
                    {
                        var designScenario = new Scenario();
                        var inputLocationDesignScenario = inputLocation.DesignScenarios[j];
                        designScenario.LocationScenarioID = inputLocationDesignScenario.Id;
                        designScenario.RiverLevel = inputLocationDesignScenario.RiverLevel;
                        designScenario.RiverLevelLow = (inputLocationDesignScenario.RiverLevelLowSpecified ? (double?)inputLocationDesignScenario.RiverLevelLow : null);
                        designScenario.DikeTableHeight = (inputLocationDesignScenario.DikeTableHeightSpecified ? (double?)inputLocationDesignScenario.DikeTableHeight : null);
                        designScenario.PlLineOffsetBelowDikeTopAtRiver = (inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtRiverSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtRiver : null);
                        designScenario.PlLineOffsetBelowDikeTopAtPolder = (inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtPolderSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtPolder : null);
                        designScenario.PlLineOffsetBelowShoulderBaseInside = (inputLocationDesignScenario.PlLineOffsetBelowShoulderBaseInsideSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowShoulderBaseInside : null);
                        designScenario.PlLineOffsetBelowDikeToeAtPolder = (inputLocationDesignScenario.PlLineOffsetBelowDikeToeAtPolderSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowDikeToeAtPolder : null);
                        designScenario.UsePlLineOffsetBelowDikeCrestMiddle = inputLocationDesignScenario.PlLineOffsetBelowDikeCrestMiddleSpecified;
                        designScenario.PlLineOffsetBelowDikeCrestMiddle = inputLocationDesignScenario.PlLineOffsetBelowDikeCrestMiddle;
                        designScenario.UsePlLineOffsetFactorBelowShoulderCrest = inputLocationDesignScenario.PlLineOffsetFactorBelowShoulderCrestSpecified;
                        designScenario.PlLineOffsetFactorBelowShoulderCrest = inputLocationDesignScenario.PlLineOffsetFactorBelowShoulderCrest;
                        designScenario.HeadPl3 = (inputLocationDesignScenario.HeadPl3Specified ? (double?)inputLocationDesignScenario.HeadPl3 : null);
                        designScenario.HeadPl4 = (inputLocationDesignScenario.HeadPl4Specified ? (double?)inputLocationDesignScenario.HeadPl4 : null);
                        designScenario.UpliftCriterionStability = (inputLocationDesignScenario.UpliftCriterionStabilitySpecified ? (double?)inputLocationDesignScenario.UpliftCriterionStability : null);
                        designScenario.UpliftCriterionPiping = (inputLocationDesignScenario.UpliftCriterionPipingSpecified ? (double?)inputLocationDesignScenario.UpliftCriterionPiping : null);
                        designScenario.RequiredSafetyFactorStabilityInnerSlope = (inputLocationDesignScenario.RequiredSafetyFactorStabilityInnerSlopeSpecified ? (double?)inputLocationDesignScenario.RequiredSafetyFactorStabilityInnerSlope : null);
                        designScenario.RequiredSafetyFactorStabilityOuterSlope = (inputLocationDesignScenario.RequiredSafetyFactorStabilityOuterSlopeSpecified ? (double?)inputLocationDesignScenario.RequiredSafetyFactorStabilityOuterSlope : null);
                        designScenario.RequiredSafetyFactorPiping = (inputLocationDesignScenario.RequiredSafetyFactorPipingSpecified ? (double?)inputLocationDesignScenario.RequiredSafetyFactorPiping : null);

                        location.Scenarios.Add(designScenario);
                    }
                }
                location.DikeEmbankmentMaterial = inputLocation.DikeEmbankmentMaterial;
                if (inputLocation.StabilityOptions != null)
                {
                    location.MapForSoilGeometries2D = inputLocation.StabilityOptions.MapForSoilgeometries2D;
                    location.StabilityZoneType = ConversionHelper.ConvertToZoneType(inputLocation.StabilityOptions.ZoneType);
                    if (inputLocation.StabilityOptions.ForbiddenZoneFactorSpecified)
                    {
                        location.ForbiddenZoneFactor = inputLocation.StabilityOptions.ForbiddenZoneFactor;
                    }
                    if (inputLocation.StabilityOptions.ZoneAreaRestSlopeCrestWidthSpecified)
                    {
                        location.ZoneAreaRestSlopeCrestWidth = inputLocation.StabilityOptions.ZoneAreaRestSlopeCrestWidth;
                    }
                    if (inputLocation.StabilityOptions.TrafficLoadSpecified)
                    {
                        location.TrafficLoad = inputLocation.StabilityOptions.TrafficLoad;
                    }
                    if (inputLocation.StabilityOptions.MinimumCircleDepthSpecified)
                    {
                        location.MinimalCircleDepth = inputLocation.StabilityOptions.MinimumCircleDepth;
                    }
                }
                dikeLocations.Add(location);
            }
        }
        private static void TransferSoilProfiles1D(DamEngine.Io.XmlInput.SoilProfile1D[] inputSoilProfiles1D,
            IList<SoilProfile1D> dikeSoilProfiles, SoilList soils)
        {
            if (inputSoilProfiles1D != null)
            {
                for (int i = 0; i < inputSoilProfiles1D.Length; i++)
                {
                    var soilProfile1D = new SoilProfile1D();
                    var inputSoilProfile1D = inputSoilProfiles1D[i];
                    soilProfile1D.Name = inputSoilProfile1D.Name;
                    soilProfile1D.BottomLevel = inputSoilProfile1D.BottomLevel;
                    AddLayers1D(inputSoilProfile1D, soilProfile1D, soils);
                    dikeSoilProfiles.Add(soilProfile1D);
                }
            }
        }

        private static void AddLayers1D(DamEngine.Io.XmlInput.SoilProfile1D inputSoilProfile1D, SoilProfile1D soilProfile1D, SoilList soils)
        {
            if (inputSoilProfile1D != null)
            {
                for (int i = 0; i < inputSoilProfile1D.Layers1D.Length; i++)
                {
                    var layer = new SoilLayer1D();
                    var inputLayer = inputSoilProfile1D.Layers1D[i];
                    layer.Id = inputLayer.Name;
                    layer.Soil = soils.GetSoilByName(inputLayer.SoilName);
                    layer.TopLevel = inputLayer.TopLevel;
                    layer.IsAquifer = inputLayer.IsAquifer;
                    layer.WaterpressureInterpolationModel = ConversionHelper.ConvertToWaterpressureInterpolationModel(
                        inputLayer.WaterpressureInterpolationModel);
                    soilProfile1D.Layers.Add(layer);
                }
            }
        }

        private static void TransferSegments(DamEngine.Io.XmlInput.Segment[] inputSegments, IList<SoilProfile1D> dikeSoilProfiles, IList<Segment> segments)
        {
            for (int i = 0; i < inputSegments.Length; i++)
            {
                var segment = new Segment();
                var inputSegment = inputSegments[i];
                segment.Name = inputSegment.Name;
                AddSoilProfileProbabilities(inputSegment, dikeSoilProfiles, segment);
                segments.Add(segment);
            }
        }

        private static void AddSoilProfileProbabilities(DamEngine.Io.XmlInput.Segment inputSegment, IList<SoilProfile1D> dikeSoilProfiles, Segment segment)
        {
            for (int i = 0; i < inputSegment.SoilGeometryProbability.Length; i++)
            {
                var soilGeometryProbability = new SoilGeometryProbability();
                var inputSoilGeometryProbability = inputSegment.SoilGeometryProbability[i];
                soilGeometryProbability.Probability = inputSoilGeometryProbability.Probability;
                if (inputSoilGeometryProbability.FailureMechanismSystemTypeSpecified)
                {
                    soilGeometryProbability.SegmentFailureMechanismType = ConversionHelper.ConvertToFailureMechanismSystemType(inputSoilGeometryProbability.FailureMechanismSystemType);
                }
                else
                {
                    soilGeometryProbability.SegmentFailureMechanismType = null;
                }
                if (inputSoilGeometryProbability.SoilProfileType == 0)
                {
                    soilGeometryProbability.SoilProfile = FindSoilProfile1DByName(dikeSoilProfiles, inputSoilGeometryProbability.SoilProfileName);
                }
                else
                {
                    soilGeometryProbability.SoilGeometry2DName = inputSoilGeometryProbability.SoilProfileName;
                }
                if (soilGeometryProbability.SoilGeometryType != ConversionHelper.ConvertToSoilGeometryType(inputSoilGeometryProbability.SoilProfileType))
                {
                    throw new ConversionException(typeof(SegmentSoilGeometryProbability), soilGeometryProbability.SoilGeometryType);
                }
                segment.SoilProfileProbabilities.Add(soilGeometryProbability);
            }
        }

        /// <summary>
        /// Finds the SoilProfile1D by name.
        /// </summary>
        /// <param name="soilProfiles">The soil profiles.</param>
        /// <param name="name">The name.</param>
        /// <returns></returns>
        public static SoilProfile1D FindSoilProfile1DByName(IList<SoilProfile1D> soilProfiles, string name)
        {
            foreach (var soilProfile1D in soilProfiles)
            {
                if (soilProfile1D.Name == name)
                    return soilProfile1D;
            }
            return null;
        }

    }
}