// Copyright (C) Stichting Deltares 2023. 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.ComponentModel;
using System.IO;
using System.Linq;
using System.Xml.Serialization;
using Deltares.Dam.Data.CsvImporters;
using Deltares.Geotechnics.Converter;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Geotechnics.Validation;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.Data;
using Deltares.Standard.Extensions;
using Deltares.Standard.Language;
using Deltares.Standard.Logging;
using Deltares.Standard.Validation;

namespace Deltares.Dam.Data;

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

public class DikeParameterNames
{
    public const string MapForSoilGeometries2D = "MapForSoilGeometries2D";
}

[TrackChanges]
public class Dike : IVisibleEnabled, IDisposable
{
    private IList<Location> locations;

    private IList<PL1Line> pl1Lines;
    private SoilList soilList;
    private IList<SoilProfile1D> soilProfiles;

    public Dike()
    {
        Name = "Dijkring";
        MapForSoilGeometries2D = "";

        locations = new List<Location>();
        soilProfiles = new List<SoilProfile1D>();

        surfaceLines = new DelegatedList<SurfaceLine>
        {
            AddMethod = ConvertAddedOldSurfaceLineToNewFormat
        };
        SurfaceLines2 = new List<SurfaceLine2>();
        pl1Lines = new List<PL1Line>();
        soilList = new SoilList();
        IsRemoveStiFiles = true;
    }

    public virtual string MapForSoilGeometries2D { get; set; }

    public bool IsRemoveStiFiles { get; set; }

    public MStabShearStrength ShearStrengthModel { get; set; }

    public virtual string Name { get; set; }

    /// <summary>
    ///     Gets the locations.
    /// </summary>
    /// <value>
    ///     The locations.
    /// </value>
    public virtual IList<Location> Locations
    {
        get => locations;
        private set => locations = value;
    }

    public IList<SurfaceLine2> SurfaceLines2 { get; set; }

    public virtual IList<PL1Line> PL1Lines
    {
        get => pl1Lines;
        set => pl1Lines = value;
    }

    public virtual IList<SoilProfile1D> SoilProfiles
    {
        get => soilProfiles;
        set => soilProfiles = value;
    }

    public virtual SoilList SoilList
    {
        get => soilList;
        set => soilList = value;
    }

    [Browsable(false)] public virtual IList<Gauge> Gauges { get; set; } = new List<Gauge>();

    [Browsable(false)] public virtual IList<GaugePLLine> GaugePLLines { get; set; } = new List<GaugePLLine>();

    public bool UsesGauges => (GaugePLLines != null) && (GaugePLLines.Count > 0) && (Gauges != null);

    public virtual List<Scenario> Scenarios
    {
        get
        {
            var scenarios = new List<Scenario>();
            foreach (Location location in Locations)
            {
                scenarios.AddRange(location.Scenarios);
            }

            return scenarios;
        }
    }

    public string Description { get; set; } = "";

    /// <summary>
    ///     Updates the locations for scenarios.
    /// </summary>
    public void UpdateLocationsForScenarios()
    {
        foreach (Location location in Locations)
        {
            foreach (Scenario scenario in location.Scenarios)
            {
                scenario.Location = location;
            }
        }
    }

    /// <summary>
    ///     Sorts the locations.
    /// </summary>
    public void SortLocations()
    {
        locations = Locations.OrderBy(o => o.Name).ToList();
    }

    public void Validate()
    {
        if ((Locations == null) || (Locations.Count < 1))
        {
            throw new DikeException("The dike ring has no locations defined");
        }

        foreach (Location location in Locations)
        {
            if (location.LocalXZSurfaceLine2 != null)
            {
                var validator = new SurfaceLine2Validator();
                ValidationResult[] validationResults = validator.ValidateCharacteristicPointsAreOrdered(location.LocalXZSurfaceLine2)
                                                                .Concat(validator.ValidateGeometryPointsAreOrdered(location.LocalXZSurfaceLine2)).ToArray();
                if (validationResults.Length > 0)
                {
                    throw new SurfaceLineException(validationResults[0].Text);
                }
            }
        }
    }

    /// <summary>
    ///     Add to soil data as read from the csv-file to the dike soils
    /// </summary>
    public void FillImportedCsvSoilsFromCsvFile(IEnumerable<CsvImporterSoils.SoilRecord> soilRecords)
    {
        if (soilRecords == null)
        {
            return;
        }

        foreach (CsvImporterSoils.SoilRecord soilRecord in soilRecords)
        {
            var soil = new Soil();
            soil.Name = soilRecord.SoilName;
            soil.Color = soilRecord.SoilColor;
            soil.SoilType = soilRecord.SoilType;

            if (soilRecord.UnsaturatedUnitWeight.HasValue)
            {
                soil.AbovePhreaticLevel = soilRecord.UnsaturatedUnitWeight.Value;
            }

            if (soilRecord.SaturatedUnitWeight.HasValue)
            {
                soil.BelowPhreaticLevel = soilRecord.SaturatedUnitWeight.Value;
            }

            if (soilRecord.Cohesion.HasValue)
            {
                soil.Cohesion = soilRecord.Cohesion.Value;
            }

            if (soilRecord.FrictionAngle.HasValue)
            {
                soil.FrictionAngle = soilRecord.FrictionAngle.Value;
            }

            if (soilRecord.DiameterD70.HasValue)
            {
                soil.DiameterD70 = soilRecord.DiameterD70.Value;
            }

            if (soilRecord.PermeabilityX.HasValue)
            {
                soil.PermeabKx = soilRecord.PermeabilityX.Value;
            }

            soil.UseDefaultShearStrengthModel = false;
            soil.ShearStrengthModel = soilRecord.ShearStrengthModel;

            if (soilRecord.StrengthIncreaseExponent.HasValue)
            {
                soil.StrengthIncreaseExponent = soilRecord.StrengthIncreaseExponent.Value;
            }

            if (soilRecord.RatioSuPc.HasValue)
            {
                soil.RatioCuPc = soilRecord.RatioSuPc.Value;
            }

            soil.UsePop = soilRecord.UsePop;

            if (soilRecord.Pop.HasValue && soilRecord.UsePop)
            {
                soil.POP = soilRecord.Pop.Value;
            }

            ImportedCsvSoils.Add(soil);
        }
    }

    /// <summary>
    ///     Adapt data so it is consistent
    /// </summary>
    /// <param name="importedCsvSoils">The soils as imported from the csv file</param>
    public IEnumerable<LogMessage> MakeDataConsistent(List<Soil> importedCsvSoils)
    {
        List<Soil> errorSoils = TryToMakeSoilDataConsistent(importedCsvSoils);
        var logMessages = new List<LogMessage>();
        // Delete all locations without surfaceline
        logMessages.AddRange(DeleteLocationsWithoutSurfaceLines());
        // Delete all locations that have profiles (in their segment) which hold soils 
        // that are not in the soil csv-file and so have no parameters.
        logMessages.AddRange(DeleteLocationsWithProfilesWithUnknownSoils(errorSoils));
        return logMessages;
    }

    public Dictionary<string, string> GetParametersAsNameValuePairs()
    {
        var nameValuePairs = new Dictionary<string, string>();
        nameValuePairs.Add(DikeParameterNames.MapForSoilGeometries2D, MapForSoilGeometries2D);
        return nameValuePairs;
    }

    public void SetParameterFromNameValuePair(string parameterName, string parameterValue)
    {
        if (parameterName.Equals(DikeParameterNames.MapForSoilGeometries2D))
        {
            MapForSoilGeometries2D = parameterValue;
        }
    }

    public void UpdateLocation(Location location)
    {
        location.SoilList = SoilList;
        location.MapForSoilGeometries2D = MapForSoilGeometries2D;

        location.Gauges.Clear();
        location.Gauges.AddRange(Gauges);

        location.GaugePLLines.Clear();
        location.GaugePLLines.AddRange(GaugePLLines);
    }

    public override string ToString()
    {
        return Name;
    }

    public void Dispose()
    {
        foreach (Location location in Locations)
        {
            location.Dispose();
        }

        foreach (SurfaceLine2 surfaceLine2 in SurfaceLines2)
        {
            surfaceLine2.Dispose();
        }
    }

    public bool IsVisible(string property)
    {
        return true;
    }

    public bool IsEnabled(string property)
    {
        switch (property)
        {
            case "Name": return false;
            case "SoilList": return false;
            default: return true;
        }
    }

    internal List<Soil> ImportedCsvSoils { get; } = new();

    /// <summary>
    ///     Tries to make the soil data as read for 1D profiles consistent with the data in the soil database.
    ///     In the end we have a neat soil list with parameters for every soil as read from the database.
    ///     We might have a list with errors (soils that were not to be found in the database so soils for which
    ///     no parameters could be found).
    /// </summary>
    /// <param name="importedCsvSoils">The soils as imported from the csv file</param>
    /// <returns></returns>
    private List<Soil> TryToMakeSoilDataConsistent(List<Soil> importedCsvSoils)
    {
        var errorSoils = new List<Soil>();
        // Fill the list of errorSoils with soils that are in the current soillist (as result of importing
        // 1D profiles) but that are not found in the soil database because that are errors
        foreach (Soil soil in soilList.Soils)
        {
            Soil fs = importedCsvSoils.Find(t => string.Equals(t.Name, soil.Name, StringComparison.CurrentCultureIgnoreCase));
            if (fs == null)
            {
                errorSoils.Add(soil);
            }
        }

        // Remove the error soils form the list
        foreach (Soil errorSoil in errorSoils)
        {
            soilList.Soils.Remove(errorSoil);
        }

        // Get the parameters for every soil in the now proper soil list from the database. Add soils
        // that are in the database but not yet in the soil list.
        foreach (Soil soil in importedCsvSoils)
        {
            Soil existingSoil = soilList.GetSoilByName(soil.Name);
            if (existingSoil == null)
            {
                soilList.Soils.Add(soil);
            }
            else
            {
                existingSoil.Assign(soil);
            }
        }

        return errorSoils;
    }

    /// <summary>
    ///     Removes all locations which have profiles that have invalid soils
    /// </summary>
    private List<LogMessage> DeleteLocationsWithProfilesWithUnknownSoils(List<Soil> invalidSoils)
    {
        var logMessages = new List<LogMessage>();
        var invalidLocations = new List<Location>();
        string soilProf;
        string invSoil;
        foreach (Location location in locations)
        {
            bool isInValid;
            var message = "";
            if (location.Segment == null)
            {
                isInValid = true;
                message = string.Format(LocalizationManager.GetTranslatedText(GetType(), "LocationWitNameHasNoSegment"), location.Name);
            }
            else
            {
                isInValid = DoesLocationHaveInvalidSoils(invalidSoils, location, out soilProf, out invSoil);
                if (isInValid)
                {
                    message = string.Format(LocalizationManager.GetTranslatedText(GetType(), "LocationHasProfileWithInvalidSoils"), location.Name, soilProf, invSoil);
                }
            }

            if (isInValid)
            {
                invalidLocations.Add(location);
                logMessages.Add(new LogMessage(LogMessageType.Warning, this, message));
            }
        }

        foreach (Location invalidLocation in invalidLocations)
        {
            locations.Remove(invalidLocation);
        }

        return logMessages;
    }

    /// <summary>
    ///     Checks wether a location (or rather the soilprofiles in the segement of the location) contains invalid soils.
    ///     A soil is hereby considered invalid if it is not found in the database.
    /// </summary>
    /// <param name="invalidSoils"></param>
    /// <param name="location"></param>
    /// <param name="soilProf"></param>
    /// <param name="invSoil"></param>
    /// <returns></returns>
    private bool DoesLocationHaveInvalidSoils(List<Soil> invalidSoils, Location location, out string soilProf, out string invSoil)
    {
        soilProf = " ";
        invSoil = " ";
        foreach (SoilGeometryProbability spp in location.Segment.SoilProfileProbabilities)
        {
            foreach (Soil invalidSoil in invalidSoils)
            {
                SoilLayer1D fl = spp.SoilProfile.Layers.Find(l => string.Equals(l.Soil.Name, invalidSoil.Name, StringComparison.CurrentCultureIgnoreCase));

                if (fl != null)
                {
                    soilProf = spp.SoilProfile.Name;
                    invSoil = invalidSoil.Name;
                    return true;
                }
            }
        }

        return false;
    }

    /// <summary>
    ///     Delete all locations without surfacelines
    /// </summary>
    private List<LogMessage> DeleteLocationsWithoutSurfaceLines()
    {
        var logMessages = new List<LogMessage>();

        //Add all locations with valid surfaceline
        var newLocations = new List<Location>();
        newLocations.AddRange(Locations.Where(loc => loc.SurfaceLine2 != null));

        // Report which locations are not added because no valid surfaceline is found
        var deletedLocations = new List<Location>();
        deletedLocations.AddRange(Locations.Where(loc => loc.SurfaceLine2 == null));
        foreach (Location deletedLocation in deletedLocations)
        {
            string locationHasNoSurfaceLine = LocalizationManager.GetTranslatedText(GetType(), "LocationHasNoSurfaceLine");
            logMessages.Add(new LogMessage(LogMessageType.Warning, this,
                                           string.Format(locationHasNoSurfaceLine, deletedLocation.Name)));
        }

        Locations = newLocations;
        return logMessages;
    }

    #region Backwards compatibility

    private IList<SurfaceLine> surfaceLines;

    /// <summary>
    ///     Gets or sets all surface lines instances associated with this dike.
    /// </summary>
    /// <remarks>
    ///     Composite owner of all <see cref="SurfaceLine" /> that are part of the
    ///     application that are associated with this dike.
    /// </remarks>
    [Obsolete("Do not use this member; Only exists for backwards compatibility.", true)]
    public virtual IList<SurfaceLine> SurfaceLines
    {
        get => surfaceLines;
        set => surfaceLines = value;
    }

    /// <summary>
    ///     Performs backwards compatibility conversion from old-style surfaceline to new-style
    ///     surfaceline, and ensures that shared references are set correctly.
    /// </summary>
    /// <param name="argument">Persisted version of the old-style surfaceline.</param>
    private void ConvertAddedOldSurfaceLineToNewFormat(SurfaceLine argument)
    {
        SurfaceLine2 surfaceLine2 = new OldSurfaceLineToNewConverter().Convert(argument);
        SurfaceLines2.Add(surfaceLine2);

        foreach (Location location in Locations)
        {
            location.SetNewSurfaceLineIfMatchesWithOldPersistedSurfaceLine(surfaceLine2);
        }

        // Remove old entry; it is no longer required.
        surfaceLines.Remove(argument);
        argument.Dispose();
    }

    #endregion
}