// Copyright (C) Stichting Deltares 2025. 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.Globalization;
using System.Linq;
using Deltares.Dam.Data.DataPlugins;
using Deltares.Dam.Data.DataPlugins.Configuration;
using Deltares.Geometry;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Maps;
using Deltares.Standard;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Logging;
using ProgressDelegate = Deltares.DamEngine.Data.Standard.Calculation.ProgressDelegate;

namespace Deltares.Dam.Data;

public class DikeImporterException : Exception
{
    public DikeImporterException(string message)
        : base(message) {}
}

/// <summary>
/// Import all data into Dike
/// </summary>
public class DikeImporter
{
    //
    // Members & Properties
    //
    private readonly IDataPlugin importer;

    private readonly Dike dike = new();

    /// <summary>
    /// Initializes a new instance of the <see cref="DikeImporter"/> class.
    /// </summary>
    /// <param name="dataFolder">The data folder.</param>
    /// <param name="dataSourceContainer">The data source container.</param>
    /// <param name="damProjectType">Type of the dam project.</param>
    private DikeImporter(string dataFolder, DataSourceContainer dataSourceContainer, DamProjectType damProjectType)
    {
        importer = CreateDataPlugin(dataFolder, dataSourceContainer);
        importer.DamProjectType = damProjectType;
    }

    /// <summary>
    /// Imports the data for one dike ring.
    /// </summary>
    /// <param name="damProjectFolder">The dam project folder.</param>
    /// <param name="dataFolder">The data folder.</param>
    /// <param name="dataSourceContainer">The data source container.</param>
    /// <param name="damProjectType">Type of the dam project.</param>
    /// <param name="progress">The progress.</param>
    /// <param name="logMessages">The log messages.</param>
    /// <returns></returns>
    public static Dike ImportDataForDikeRing(string damProjectFolder, string dataFolder,
                                                    DataSourceContainer dataSourceContainer,
                                                    DamProjectType damProjectType, ProgressDelegate progress, 
                                                    out List<LogMessage> logMessages)
    {
        var importer = new DikeImporter(dataFolder, dataSourceContainer, damProjectType);

        logMessages = new List<LogMessage>();
        var dike = new Dike();
        try
        {
            dike = importer.ImportDataForDikeRing(damProjectFolder, progress);

            if (string.IsNullOrEmpty(dike.MapForSoilGeometries2D) && !string.IsNullOrEmpty(dataSourceContainer.MapSoilProfile2D))
            {
                dike.MapForSoilGeometries2D = dataSourceContainer.MapSoilProfile2D;
            }
        }
        catch (Exception e)
        {
            string errorMessage = e.Message;
            Exception innerException = e.InnerException;
            while (innerException != null)
            {
                errorMessage = errorMessage + ";" + innerException.Message;
                innerException = innerException.InnerException;
            }

            logMessages.Add(new LogMessage(LogMessageType.FatalError, null, errorMessage));
        }

        logMessages.AddRange(importer.ImportCsvLogMessages);

        return dike;
    }

    /// <summary>
    /// Gets the import CSV log messages.
    /// </summary>
    /// <value>
    /// The import CSV log messages.
    /// </value>
    private List<LogMessage> ImportCsvLogMessages { get; } = new();

    /// <summary>
    /// Creates the data plugin.
    /// </summary>
    /// <param name="dataFolder">The data folder.</param>
    /// <param name="dataSourceContainer">The data source container.</param>
    /// <returns></returns>
    private static DataPluginImporter CreateDataPlugin(string dataFolder, DataSourceContainer dataSourceContainer)
    {
        var plugin = new DataPluginImporter();
        plugin.SetDataSources(dataFolder, dataSourceContainer.DataSourceList);
        plugin.Attributes = dataSourceContainer.DataAttributes;

        return plugin;
    }

    /// <summary>
    /// Imports the data for one dike ring.
    /// </summary>
    /// <param name="damProjectFolder">The dam project folder.</param>
    /// <param name="progress">The progress.</param>
    /// <returns></returns>
    private Dike ImportDataForDikeRing(string damProjectFolder, ProgressDelegate progress)
    {
        importer.DamProjectFolder = damProjectFolder;

        // Import dike
        bool importOk = ImportDike(progress);

        if (!importOk)
        {
            return dike;
        }

        // Add dike other data
        List<DamSoil> importedCsvSoils = importer.Dike.ImportedCsvSoils;
        IEnumerable<Aquifer> importedCsvAquifers = importer.Dike.Aquifers;
        Dike importedDike = ImportDataForDikeRing(importedCsvSoils, importedCsvAquifers, "Dijkring");

        ImportBackground();
        return importedDike;
    }

    /// <summary>
    /// Imports the soils.
    /// </summary>
    /// <param name="dike">The dike.</param>
    private void ImportSoils(Dike dike)
    {
        List<DamSoil> soils = GetSoils();
        foreach (DamSoil soil in soils)
        {
            dike.AddDamSoil(soil);
        }
    }

    /// <summary>
    /// Gets the soils.
    /// </summary>
    /// <returns></returns>
    private List<DamSoil> GetSoils()
    {
        IEnumerable<string> soilIdList = importer.GetSoilIdList();
        List<DamSoil> soils = soilIdList.Select(soilId => ImportSoil(soilId)).ToList();

        return soils;
    }

    /// <summary>
    /// Imports a soil.
    /// </summary>
    /// <param name="soilID">The soil identifier.</param>
    /// <returns></returns>
    private DamSoil ImportSoil(string soilID)
    {
        var soil = new DamSoil
        {
            Name = soilID
        };
        IEnumerable<NameValueParameter> soilDetails = importer.GetSoilDetails(soilID);

        foreach (NameValueParameter soilDetail in soilDetails)
        {
            SoilUtils.SetParameterFromNameValuePair(soil, soilDetail.ParameterName, soilDetail.ParameterValue);
            DataSourceManager.SetSource(soil, soilDetail.ParameterName, soilDetail.Source);
        }

        return soil;
    }

    /// <summary>
    /// Imports the data for dike ring.
    /// </summary>
    /// <param name="importedCsvSoils">The soils as imported from the csv file</param>
    /// <param name="importedCsvAquifers">The aquifers as imported from the csv file</param>
    /// <param name="dikeRingId">The dike ring identifier.</param>
    /// <returns></returns>
    private Dike ImportDataForDikeRing(List<DamSoil> importedCsvSoils, IEnumerable<Aquifer> importedCsvAquifers, string dikeRingId)
    {
        var dike = new Dike
        {
            Name = dikeRingId
        };
        ImportSoils(dike);

        ImportSoilProfiles1D(dike);

        ImportAquifers(importedCsvAquifers, dike);

        ImportSegments(dike);

        ImportSurfaceLines(dike);

        ImportModelParameters(dike);

        ImportLocations(dike);

        ImportScenarios(dike);

        // Use InvokeWithoutPublishingEvents for performance reasons after introducing SurfaceLine2
        DataEventPublisher.InvokeWithoutPublishingEvents(() =>
        {
            var dikeCoordinateSystemConverter = new DikeCoordinateSystemConverter();
            if (dike.Locations.Count > 0)
            {
                dikeCoordinateSystemConverter.CreateLocalXZObjects(dike);
            }
        });

        ImportCsvLogMessages.AddRange(dike.MakeDataConsistent(importedCsvSoils));

        DisposeImportedItem();

        return dike;
    }

    private void DisposeImportedItem()
    {
        importer.DisposeImportedItem();
    }

    /// <summary>
    /// Imports the dike.
    /// </summary>
    /// <param name="progress">The progress.</param>
    /// <returns></returns>
    private bool ImportDike(ProgressDelegate progress)
    {
        // Import dikes
        importer.ImportDataForDike(progress);

        // add log messages
        ImportCsvLogMessages.AddRange(importer.ImportLogMessages);

        // import is ok if no fatal messages
        return ImportCsvLogMessages.All(message => message.MessageType != LogMessageType.FatalError);
    }

    /// <summary>
    /// Imports the background layer.
    /// </summary>
    private void ImportBackground()
    {
        IEnumerable<Feature> geometryFeatures = importer.MapGeometryIdList
                                                        .Select(id => importer.GetMapGeometry(id))
                                                        .Select(Feature.Create);

        foreach (Feature geometry in geometryFeatures)
        {
            dike.AddBackgroundGeometry(geometry);
        }

        dike.FillFeatureList();
    }

    /// <summary>
    /// Imports the scenarios.
    /// </summary>
    /// <param name="dike">The dike.</param>
    private void ImportScenarios(Dike dike)
    {
        AddScenariosToLocations(dike);
    }

    /// <summary>
    /// Adds the scenarios to locations.
    /// </summary>
    /// <param name="dike">The dike.</param>
    private void AddScenariosToLocations(Dike dike)
    {
        foreach (Location location in dike.Locations)
        {
            IEnumerable<string> scenarioList = importer.GetScenarioList(location.Name);
            foreach (string scenarioId in scenarioList)
            {
                IEnumerable<NameValueParameter> nameValues =
                    importer.GetScenarioDetails(location.Name, scenarioId);
                var scenario = new Scenario
                {
                    LocationScenarioID = scenarioId
                };
                foreach (NameValueParameter nameValueParameter in nameValues)
                {
                    scenario.SetParameterFromNameValuePair(
                        nameValueParameter.ParameterName,
                        nameValueParameter.ParameterValue);
                }

                scenario.Location = location;
                location.Scenarios.Add(scenario);
            }
        }
    }

    /// <summary>
    /// Imports the locations.
    /// </summary>
    /// <param name="dike">The dike.</param>
    private void ImportLocations(Dike dike)
    {
        IEnumerable<string> locationIdList = importer.GetLocationIdList();

        foreach (string locationId in locationIdList)
        {
            var location = new Location
            {
                Name = locationId
            };

            Info locationInfo = importer.GetLocationInfo(locationId);

            location.Name = locationInfo.Name;
            DataSourceManager.SetSource(location, "Name", locationInfo.Source);

            location.Description = locationInfo.Description;
            DataSourceManager.SetSource(location, "Description", locationInfo.Source);

            IEnumerable<NameValueParameter> locationDetails = importer.GetLocationDetails(locationId);
            foreach (NameValueParameter locationDetail in locationDetails)
            {
                location.SetParameterFromNameValuePair(locationDetail.ParameterName, locationDetail.ParameterValue);
                DataSourceManager.SetSource(location, locationDetail.ParameterName, locationDetail.Source);
                if (locationDetail.ParameterName.Equals(LocationParameterNames.SegmentId))
                {
                    Segment segment = dike.Segments.FirstOrDefault(x => x.Name.Equals(locationDetail.ParameterValue));
                    location.Segment = segment;
                }

                // See comment below, ID is still needed (this was proved with old tests)
                if (locationDetail.ParameterName.Equals(LocationParameterNames.SurfaceLineId))
                {
                    SurfaceLine2 surfaceLine = dike.SurfaceLines2.FirstOrDefault(x => x.Name.Equals(locationDetail.ParameterValue));
                    location.SurfaceLine2 = surfaceLine;
                }
                // TODO: Assign PL1-line 
            }

            // According to Erik Vastenburg, locations and surfacelines must match for matching pairs! So to find proper surfaceline
            // for location, just search for it by name in surfacelines. SurfaceLineId can and should be removed entirely! But see above!
            if (location.SurfaceLine2 == null)
            {
                location.SurfaceLine2 = dike.SurfaceLines2.FirstOrDefault(s => s.Name == location.Name);
            }

            location.SoilList = dike.SoilList;
            dike.Locations.Add(location);
        }

        dike.SortLocations();
    }

    /// <summary>
    /// Imports the model parameters.
    /// </summary>
    /// <param name="dike">The dike.</param>
    private void ImportModelParameters(Dike dike)
    {
        IEnumerable<NameValueParameter> modelParameters = importer.GetDikeParameters();
        foreach (NameValueParameter modelParameter in modelParameters)
        {
            dike.SetParameterFromNameValuePair(modelParameter.ParameterName, modelParameter.ParameterValue);
            DataSourceManager.SetSource(dike, modelParameter.ParameterName, modelParameter.Source);
        }
    }

    /// <summary>
    /// Imports the surface lines.
    /// </summary>
    /// <param name="dike">The dike.</param>
    private void ImportSurfaceLines(Dike dike)
    {
        // Use InvokeWithoutPublishingEvents for performance reasons after introducing SurfaceLine2
        DataEventPublisher.InvokeWithoutPublishingEvents(() =>
        {
            IEnumerable<string> surfaceLineIdList = importer.GetSurfaceLineIdList();
            foreach (string surfaceLineId in surfaceLineIdList)
            {
                var surfaceLine = new SurfaceLine2
                {
                    Name = surfaceLineId,
                    Geometry = new LocalizedGeometryPointString(),
                    CharacteristicPoints =
                    {
                        GeometryMustContainPoint = true
                    }
                };

                // load the surface line points
                IList<GeometryPoint> surfaceLinePoints = importer.GetSurfaceLinePoints(surfaceLineId);
                foreach (GeometryPoint surfaceLinePoint in surfaceLinePoints)
                {
                    surfaceLine.AddCharacteristicPoint(surfaceLinePoint);
                }

                // load the characteristic points
                IEnumerable<DpCharacteristicPoint> characteristicPoints = importer.GetSurfaceLineCharacteristicPoints(surfaceLineId);
                foreach (DpCharacteristicPoint cp in characteristicPoints)
                {
                    var cpType = (CharacteristicPointType) Enum.Parse(
                        typeof(CharacteristicPointType), cp.Id);
                    surfaceLine.EnsurePointOfType(cp.X, cp.Y, cp.Z, cpType);
                }

                // add the surface line to the dike
                dike.SurfaceLines2.Add(surfaceLine);
            }
        });
    }

    /// <summary>
    /// Imports the segments.
    /// </summary>
    /// <param name="dike">The dike.</param>
    private void ImportSegments(Dike dike)
    {
        IEnumerable<string> segmentIdList = importer.GetSegmentIdList();
        foreach (string segmentID in segmentIdList)
        {
            var segment = new Segment
            {
                Name = segmentID
            };

            foreach (FailureMechanismSystemType failureMechanismSystemType in Enum.GetValues(typeof(FailureMechanismSystemType)))
            {
                AddSoilProfiles(segment, segmentID, failureMechanismSystemType, dike);
                AddSoilGeometry(segment, segmentID, failureMechanismSystemType);
            }

            dike.Segments.Add(segment);
        }
    }

    /// <summary>
    /// Adds the soil profiles.
    /// </summary>
    /// <param name="segment">The segment.</param>
    /// <param name="segmentID">The segment identifier.</param>
    /// <param name="failureMechanismSystemType">Type of the failure mechanism system.</param>
    /// <param name="dike">The dike.</param>
    private void AddSoilProfiles(Segment segment, string segmentID, FailureMechanismSystemType failureMechanismSystemType, Dike dike)
    {
        IEnumerable<string> profile1DIdListForSegment = importer.GetProfile1DIdListForSegment(segmentID, failureMechanismSystemType);

        foreach (string soilProfile1DId in profile1DIdListForSegment)
        {
            var numberFormatInfo = new NumberFormatInfo
            {
                NumberDecimalSeparator = "."
            };

            // get soil profile
            IEnumerable<NameValueParameter> soilProfile1DDetails = importer.GetSegmentProfile1DDetails(segmentID, soilProfile1DId, failureMechanismSystemType);
            SoilProfile1D soilProfile1D = dike.SoilProfiles.FirstOrDefault(x => x.Name.Equals(soilProfile1DId));

            double probability = 0;
            foreach (NameValueParameter nameValueparameter in soilProfile1DDetails)
            {
                if (nameValueparameter.ParameterName.Equals("Probability"))
                {
                    probability = Convert.ToDouble(nameValueparameter.ParameterValue, numberFormatInfo);
                }
            }

            segment.AddSoilProfileProbability(soilProfile1D, probability, failureMechanismSystemType);
        }
    }

    /// <summary>
    /// Adds the soil geometry.
    /// </summary>
    /// <param name="segment">The segment.</param>
    /// <param name="segmentID">The segment identifier.</param>
    /// <param name="failureMechanismSystemType">Type of the failure mechanism system.</param>
    private void AddSoilGeometry(Segment segment, string segmentID, FailureMechanismSystemType failureMechanismSystemType)
    {
        IEnumerable<string> profile2DIdListForSegment = importer.GetProfile2DIdListForSegment(segmentID, failureMechanismSystemType);
        foreach (string soilGeometry2DName in profile2DIdListForSegment)
        {
            var numberFormatInfo = new NumberFormatInfo
            {
                NumberDecimalSeparator = "."
            };
            IEnumerable<NameValueParameter> soilProfile2DDetails = importer.GetSegmentProfile2DDetails(segmentID, soilGeometry2DName, failureMechanismSystemType);
            var probability = 0.0;
            foreach (NameValueParameter nameValueparameter in soilProfile2DDetails)
            {
                if (nameValueparameter.ParameterName.Equals("Probability"))
                {
                    probability = Convert.ToDouble(nameValueparameter.ParameterValue, numberFormatInfo);
                }
            }

            segment.AddSoilGeometry2DProbability(soilGeometry2DName, probability, failureMechanismSystemType);
        }
    }

    /// <summary>
    /// Imports the soil profiles1 d.
    /// </summary>
    /// <param name="dike">The dike.</param>
    private void ImportSoilProfiles1D(Dike dike)
    {
        IEnumerable<string> soilProfile1DIdList = importer.GetSoilProfile1DIdList();
        foreach (string soilProfile1DId in soilProfile1DIdList)
        {
            dike.SoilProfiles.Add(ImportProfile(soilProfile1DId, dike));
        }
    }

    private static void ImportAquifers(IEnumerable<Aquifer> importedCsvAquifers, Dike dike)
    {
        foreach (Aquifer aquifer in importedCsvAquifers)
        {
            dike.Aquifers.Add(aquifer);
        }
    }

    /// <summary>
    /// Imports a profile.
    /// </summary>
    /// <param name="soilProfile1DId">The soil profile1 d identifier.</param>
    /// <param name="dike">The dike.</param>
    /// <returns></returns>
    /// <exception cref="DikeImporterException">
    /// </exception>
    private SoilProfile1D ImportProfile(string soilProfile1DId, Dike dike)
    {
        var soilProfile = new SoilProfile1D
        {
            Name = soilProfile1DId
        };
        var bottomLevel = 0.0;

        DpSoilProfile dpSoilProfile = importer.GetSoilProfile1DDetails(soilProfile1DId);
        for (var layerIndex = 0; layerIndex < dpSoilProfile.Layers.Count; layerIndex++)
        {
            DpLayer layer = dpSoilProfile.Layers[layerIndex];
            if (layer.SoilName == SoilProfile1D.SoilProfileBottomLevelId)
            {
                // This is a hack to communicate the bottom level via a layer
                bottomLevel = layer.TopLevel;
            }
            else
            {
                int soilIndex = dike.SoilList.GetSoilIndexByName(layer.SoilName);
                if (soilIndex < 0)
                {
                    throw new DikeImporterException($"Soil '{dpSoilProfile.Layers[layerIndex].SoilName}' not found in 1d-profile '{soilProfile1DId}'");
                }

                soilProfile.Layers.Add(new SoilLayer1D
                {
                    TopLevel = layer.TopLevel,
                    Soil = dike.SoilList.Soils[soilIndex],
                    IsAquifer = layer.IsAquifer
                });
            }
        }

        soilProfile.EnsureUniqueLayerIds();
        soilProfile.BottomLevel = bottomLevel;
        if (soilProfile.LayerCount > 0)
        {
            soilProfile.EnsureLastLayerHasHeight();
        }
        else
        {
            throw new DikeImporterException($"Soil 1d-profile '{soilProfile.Name}' has no layers");
        }

        return soilProfile;
    }
}