// Copyright (C) Stichting Deltares 2019. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System.Collections.Generic;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.MacroStability.Data;
using Deltares.MacroStability.Kernel;
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 GeometrySurface = Deltares.MacroStability.Geometry.GeometrySurface;
using Point2D = Deltares.MacroStability.Geometry.Point2D;
using SurfaceLine2 = Deltares.DamEngine.Data.Geotechnics.SurfaceLine2;

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 Data.Geotechnics.SoilProfile2D SoilProfile2D { get; set; }
        /// <summary>Gets or sets the SurfaceLine2 DamEngine object.</summary>
        /// <value>The surface line2.</value>
        public Data.Geotechnics.SurfaceLine2 SurfaceLine2 { 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>();
        /// <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)
        {
            SoilList = new SoilList();
            Location = new Location();
            SoilProfile2D = new Data.Geotechnics.SoilProfile2D();
            SurfaceLine2 = new Data.Geotechnics.SurfaceLine2();
            FailureMechanismParametersMStab = new FailureMechanismParametersMStab();
            TransferWtiStabilityModel(kernelModel.StabilityModel, FailureMechanismParametersMStab);
            TransferSoils(kernelModel.StabilityModel.Soils);
            TransferSoilProfile2D(kernelModel.StabilityModel.SoilProfile);
            TransferSurfaceLine(kernelModel.PreprocessingModel.LastStage.SurfaceLine, SurfaceLine2);
            //            TransferLocation(kernelModel, Location);
            //            TransferSurfaceLine2(kernelModel, SurfaceLine2);
            //            TransferParametersMStab(kernelModel, FailureMechanismParametersMStab);
        }

        private void TransferSurfaceLine(MacroStability.Geometry.SurfaceLine2 kernelSurfaceLine2, SurfaceLine2 damSurfaceLine)
        {
            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
                    }
                };
                damSurfaceLine.CharacteristicPoints.Add(damCharPoint);
            }
        }

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

        private void TransferWtiStabilityModel(StabilityModel kernelModelStabilityModel, FailureMechanismParametersMStab 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 TransferParametersMStab(KernelModel kernelModel, FailureMechanismParametersMStab failureMechanismParametersMStab)
        {
            throw new System.NotImplementedException();
        }

        private void TransferSurfaceLine2()
        {
            throw new System.NotImplementedException();
        }

        private void TransferSoilProfile2D(MacroStability.Geometry.SoilProfile2D kernelsoilProfile2D)
        {
            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);
            }
        }

        private void TransferLocation(KernelModel kernelModel, Location location)
        {
            throw new System.NotImplementedException();
        }
    }
}