// 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;
using System.Collections.Generic;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.MacroStability.Data;
using Deltares.MacroStability.Kernel;
using Deltares.MacroStability.Preprocessing;
using Deltares.SoilStress.Data;
using Soil = Deltares.MacroStability.Geometry.Soil;
using CharacteristicPoint = Deltares.DamEngine.Data.Geotechnics.CharacteristicPoint;
using GeometryCurve = Deltares.MacroStability.Geometry.GeometryCurve;
using GeometryLoop = Deltares.MacroStability.Geometry.GeometryLoop;
using GeometryPointString = Deltares.MacroStability.Geometry.GeometryPointString;
using GeometrySurface = Deltares.MacroStability.Geometry.GeometrySurface;
using Point2D = Deltares.MacroStability.Geometry.Point2D;
using SurfaceLine2 = Deltares.DamEngine.Data.Geotechnics.SurfaceLine2;
using Waternet = Deltares.MacroStability.Geometry.Waternet;

namespace Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo
{
    /// <summary>Fill DamEngine data objects from the kernel data model</summary>
    public class FillDamEngineFromWti
    {
        /// <summary>Gets or sets the SoilList DamEngine object</summary>
        /// <value>The soil list.</value>
        public SoilList SoilList { get; set; }
        /// <summary>Gets or sets the location DamEngine object.</summary>
        /// <value>The location.</value>
        public Location Location { get; set; }
        /// <summary>Gets or sets the SoilProfile2D DamEngine object.</summary>
        /// <value>The soil profile2 d.</value>
        public SoilProfile2D SoilProfile2D { get; set; }
        /// <summary>Gets or sets the SurfaceLine2 DamEngine object.</summary>
        /// <value>The surface line2.</value>
        public SurfaceLine2 SurfaceLine2 { get; set; }
        /// <summary>Gets or sets the waternet.</summary>
        /// <value>The waternet.</value>
        public Data.Geometry.Waternet Waternet { get; set; }
        /// <summary>Gets or sets the UpliftVan calculation grid.</summary>
        /// <value>The uplift van calculation grid.</value>
        public UpliftVanCalculationGrid UpliftVanCalculationGrid { get; set; }
        /// <summary>Gets or sets the traffic load.</summary>
        /// <value>The traffic load.</value>
        public TrafficLoad TrafficLoad { get; set; }
        /// <summary>Gets or sets the failure mechanism parameters m stab.</summary>
        /// <value>The failure mechanism parameters for macrostability DamEngine object.</value>
        public FailureMechanismParametersMStab FailureMechanismParametersMStab { get; set; }

        private Dictionary<string, Data.Geotechnics.Soil> dictSoils = new Dictionary<string, Data.Geotechnics.Soil>();
        private Dictionary<GeometryPointString, Data.Geometry.GeometryPointString> dictHeadLines = new Dictionary<GeometryPointString, Data.Geometry.GeometryPointString>();
        /// <summary>Creates the dam project data from the kernel model.</summary>
        /// <param name="kernelModel">The kernel model.</param>
        /// <returns>The DamProjectData object filled with Wti data</returns>
        public void FillDamProjectDataFromKernelModel(KernelModel kernelModel)
        {
            Location = null;
            TransferWtiStabilityModel(kernelModel.StabilityModel);
            TransferSoils(kernelModel.StabilityModel.Soils);
            TransferSoilProfile2D(kernelModel.StabilityModel.SoilProfile);
            TransferSurfaceLine(kernelModel.PreprocessingModel.LastStage.SurfaceLine);
            TransferWaternet(kernelModel.StabilityModel.LastStage.GeotechnicsData.CurrentWaternet);
            TransferUpliftVanCalculationGrid(kernelModel.StabilityModel.SlipPlaneUpliftVan, kernelModel.PreprocessingModel.SearchAreaConditions);
            TransferTrafficLoad(kernelModel.StabilityModel.LastStage.UniformLoads);
        }

        private void TransferTrafficLoad(List<UniformLoad> kernelUniformLoads)
        {
            TrafficLoad = null;
            if ((kernelUniformLoads != null) && (kernelUniformLoads.Count > 0))
            {
                if (kernelUniformLoads.Count > 1)
                {
                    throw new ArgumentException(string.Format(
                        "Trafficload cannot be constructed because there are too many uniform loads defined ({0}", 
                         kernelUniformLoads.Count));
                }
                var kernelUniformLoad = kernelUniformLoads[0];
                TrafficLoad = new TrafficLoad()
                {
                    XStart = kernelUniformLoad.XStart,
                    XEnd = kernelUniformLoad.XEnd,
                    Pressure = kernelUniformLoad.Pressure
                };
            }
        }

        private void TransferUpliftVanCalculationGrid(SlipPlaneUpliftVan kernelSlipPlaneUpliftVan,
            SearchAreaConditions kernelSearchAreaConditions)
        {
            UpliftVanCalculationGrid = new UpliftVanCalculationGrid();
            UpliftVanCalculationGrid.IsAuto = kernelSearchAreaConditions.AutoSearchArea;
            UpliftVanCalculationGrid.LeftGridXCount = kernelSlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXNumber;
            UpliftVanCalculationGrid.LeftGridXLeft = kernelSlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXLeft;
            UpliftVanCalculationGrid.LeftGridXRight = kernelSlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXRight;
            UpliftVanCalculationGrid.LeftGridZCount = kernelSlipPlaneUpliftVan.SlipPlaneLeftGrid.GridZNumber;
            UpliftVanCalculationGrid.LeftGridZTop = kernelSlipPlaneUpliftVan.SlipPlaneLeftGrid.GridZTop;
            UpliftVanCalculationGrid.LeftGridZBottom = kernelSlipPlaneUpliftVan.SlipPlaneLeftGrid.GridZBottom;
            UpliftVanCalculationGrid.RightGridXCount = kernelSlipPlaneUpliftVan.SlipPlaneRightGrid.GridXNumber;
            UpliftVanCalculationGrid.RightGridXLeft = kernelSlipPlaneUpliftVan.SlipPlaneRightGrid.GridXLeft;
            UpliftVanCalculationGrid.RightGridXRight = kernelSlipPlaneUpliftVan.SlipPlaneRightGrid.GridXRight;
            UpliftVanCalculationGrid.RightGridZCount = kernelSlipPlaneUpliftVan.SlipPlaneRightGrid.GridZNumber;
            UpliftVanCalculationGrid.RightGridZTop = kernelSlipPlaneUpliftVan.SlipPlaneRightGrid.GridZTop;
            UpliftVanCalculationGrid.RightGridZBottom = kernelSlipPlaneUpliftVan.SlipPlaneRightGrid.GridZBottom;
            UpliftVanCalculationGrid.TangentLineAutomaticAtBoundaries = kernelSearchAreaConditions.AutoTangentLines;
            UpliftVanCalculationGrid.TangentLineCount = kernelSlipPlaneUpliftVan.SlipPlaneTangentLine.TangentLineNumber;
            UpliftVanCalculationGrid.TangentLineZTop = kernelSlipPlaneUpliftVan.SlipPlaneTangentLine.TangentLineZTop;
            UpliftVanCalculationGrid.TangentLineZBottom = kernelSlipPlaneUpliftVan.SlipPlaneTangentLine.TangentLineZBottom;
        }

        private void TransferWaternet(Waternet kernelWaternet)
        {
            Waternet = new Data.Geometry.Waternet();
            // Properties
            Waternet.IsGenerated = kernelWaternet.IsGenerated;
            Waternet.UnitWeight = kernelWaternet.UnitWeight;

            // Phreatic Line
            var damPhreaticLine = new PhreaticLine()
            {
                Name = kernelWaternet.PhreaticLine.Name
            };
            foreach (var kernelPoint in kernelWaternet.PhreaticLine.CalcPoints)
            {
                damPhreaticLine.CalcPoints.Add(new Data.Geometry.Point2D(kernelPoint.X, kernelPoint.Z));
            }
            dictHeadLines.Add(kernelWaternet.PhreaticLine, damPhreaticLine);
            Waternet.PhreaticLine = damPhreaticLine;

            // Head Lines
            foreach (var kernelHeadLine in kernelWaternet.HeadLineList)
            {
                var damHeadLine = new HeadLine()
                {
                    Name = kernelHeadLine.Name
                };
                foreach (var kernelPoint in kernelHeadLine.CalcPoints)
                {
                    damHeadLine.CalcPoints.Add(new Data.Geometry.Point2D(kernelPoint.X, kernelPoint.Z));
                }
                Waternet.HeadLineList.Add(damHeadLine);
                dictHeadLines.Add(kernelHeadLine, damHeadLine);
            }

            // Waternet Lines
            foreach (var kernelWaternetLine in kernelWaternet.WaternetLineList)
            {
                var damWaternetLine = new WaternetLine()
                {
                    Name = kernelWaternetLine.Name
                };
                foreach (var kernelPoint in kernelWaternetLine.CalcPoints)
                {
                    damWaternetLine.CalcPoints.Add(new Data.Geometry.Point2D(kernelPoint.X, kernelPoint.Z));
                }

                damWaternetLine.HeadLine = dictHeadLines[kernelWaternetLine.HeadLine];
                Waternet.WaternetLineList.Add(damWaternetLine);
            }
        }

        private void TransferSurfaceLine(MacroStability.Geometry.SurfaceLine2 kernelSurfaceLine2)
        {
            SurfaceLine2 = new SurfaceLine2();
            foreach (var kernelCharPoint in kernelSurfaceLine2.CharacteristicPoints)
            {
                CharacteristicPoint damCharPoint;
                damCharPoint = new CharacteristicPoint()
                {
                    CharacteristicPointType = ConversionHelper.ConvertToDamCharacteristicPointType(kernelCharPoint.CharacteristicPointType),
                    GeometryPoint = new GeometryPoint()
                    {
                        X = kernelCharPoint.X,
                        Z = kernelCharPoint.Z
                    }
                };
                SurfaceLine2.CharacteristicPoints.Add(damCharPoint);
            }
        }

        private void TransferSoils(IList<Soil> stabilityModelSoils)
        {
            SoilList = new SoilList();
            foreach (Soil kernelSoil in stabilityModelSoils)
            {
                var damSoil = ConversionHelper.ConvertToDamSoil(kernelSoil);
                dictSoils.Add(kernelSoil.Name, damSoil);
                SoilList.Add(damSoil);
            }
        }

        private void TransferWtiStabilityModel(StabilityModel kernelModelStabilityModel)
        {
            FailureMechanismParametersMStab = new FailureMechanismParametersMStab();
            // kernelModelStabilityModel.MoveGrid is not in DamEngine datamodel
            // kernelModelStabilityModel.MaximumSliceWidth is not in DamEngine datamodel
            FailureMechanismParametersMStab.MStabParameters.SearchMethod =
                ConversionHelper.ConvertToDamSearchMethod(kernelModelStabilityModel.SearchAlgorithm);
            FailureMechanismParametersMStab.MStabParameters.Model =
                ConversionHelper.ConvertToMStabModelType(kernelModelStabilityModel.ModelOption);
            FailureMechanismParametersMStab.MStabParameters.GridPosition =
                ConversionHelper.ConvertToMStabGridPosition(kernelModelStabilityModel.GridOrientation);
        }

        private void TransferSoilProfile2D(MacroStability.Geometry.SoilProfile2D kernelsoilProfile2D)
        {
            SoilProfile2D = new SoilProfile2D();
            Dictionary<Point2D, Data.Geometry.Point2D> dictPoints = new Dictionary<Point2D, Data.Geometry.Point2D>();
            Dictionary<GeometryCurve, Data.Geometry.GeometryCurve> dictCurves = new Dictionary<GeometryCurve, Data.Geometry.GeometryCurve>();
            Dictionary<GeometryLoop, Data.Geometry.GeometryLoop> dictLoops = new Dictionary<GeometryLoop, Data.Geometry.GeometryLoop>();
            Dictionary<GeometrySurface, Data.Geometry.GeometrySurface> dictSurfaces = new Dictionary<GeometrySurface, Data.Geometry.GeometrySurface>();
            // Add points
            foreach (var kernelPoint in kernelsoilProfile2D.Geometry.Points)
            {
                Data.Geometry.Point2D damPoint;
                if (dictPoints.ContainsKey(kernelPoint))
                {
                    damPoint = dictPoints[kernelPoint];
                }
                else
                {
                    damPoint = new Data.Geometry.Point2D() { X = kernelPoint.X, Z = kernelPoint.Z };
                    dictPoints.Add(kernelPoint, damPoint);
                }
                SoilProfile2D.Geometry.Points.Add(damPoint);
            }

            // Add curves
            foreach (var kernelCurve in kernelsoilProfile2D.Geometry.Curves)
            {
                Data.Geometry.GeometryCurve damCurve;
                if (dictCurves.ContainsKey(kernelCurve))
                {
                    damCurve = dictCurves[kernelCurve];
                }
                else
                {
                    var kernelHeadPoint = kernelCurve.HeadPoint;
                    var kernelEndPoint = kernelCurve.EndPoint;
                    var damHeadPoint = dictPoints[kernelHeadPoint];
                    var damEndPoint = dictPoints[kernelEndPoint];
                    damCurve = new Data.Geometry.GeometryCurve() { HeadPoint = damHeadPoint, EndPoint = damEndPoint };
                    dictCurves.Add(kernelCurve, damCurve);
                }
                SoilProfile2D.Geometry.Curves.Add(damCurve);
            }

            // Add loops
            foreach (var kernelLoop in kernelsoilProfile2D.Geometry.Loops)
            {
                Data.Geometry.GeometryLoop damLoop;
                if (dictLoops.ContainsKey(kernelLoop))
                {
                    damLoop = dictLoops[kernelLoop];
                }
                else
                {
                    damLoop = new Data.Geometry.GeometryLoop() { Name = kernelLoop.Name };
                    foreach (var damCurve in kernelLoop.CurveList)
                    {
                        damLoop.CurveList.Add(dictCurves[damCurve]);
                    }

                    dictLoops.Add(kernelLoop, damLoop);
                }
                SoilProfile2D.Geometry.Loops.Add(damLoop);
            }

            // Add surfaces
            foreach (var kernelSurface in kernelsoilProfile2D.Geometry.Surfaces)
            {
                Data.Geometry.GeometrySurface damSurface;
                if (dictSurfaces.ContainsKey(kernelSurface))
                {
                    damSurface = dictSurfaces[kernelSurface];
                }
                else
                {
                    damSurface = new Data.Geometry.GeometrySurface() { Name = kernelSurface.Name };
                    damSurface.OuterLoop = dictLoops[kernelSurface.OuterLoop];
                    foreach (var damInnerLoop in kernelSurface.InnerLoops)
                    {
                        damSurface.InnerLoops.Add(dictLoops[damInnerLoop]);
                    }

                    dictSurfaces.Add(kernelSurface, damSurface);
                }

                SoilProfile2D.Geometry.Surfaces.Add(damSurface);
            }

            // Add soil surfaces
            foreach (var kernelSoilLayer2D in kernelsoilProfile2D.Surfaces)
            {
                SoilLayer2D damSoilLayer2D = new SoilLayer2D();
                damSoilLayer2D.GeometrySurface = dictSurfaces[kernelSoilLayer2D.GeometrySurface];
                damSoilLayer2D.Soil = dictSoils[kernelSoilLayer2D.Soil.Name];
                damSoilLayer2D.IsAquifer = kernelSoilLayer2D.IsAquifer;
                damSoilLayer2D.WaterpressureInterpolationModel = ConversionHelper.ConvertToDamWaterpressureInterpolationModel(kernelSoilLayer2D.WaterpressureInterpolationModel);
                SoilProfile2D.Surfaces.Add(damSoilLayer2D);
            }
        }

    }
}