// Copyright (C) Stichting Deltares 2024. 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 System.ComponentModel;
using System.Linq;
using Deltares.DamEngine.Data.Design;
using Deltares.DamEngine.Data.General.Gauges;
using Deltares.DamEngine.Data.General.PlLines;
using Deltares.DamEngine.Data.General.TimeSeries;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Properties;
using Deltares.DamEngine.Data.Standard;
using Deltares.DamEngine.Data.Standard.Language;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.DamEngine.Data.Standard.Validation;

namespace Deltares.DamEngine.Data.General;

/// <summary>
/// Class holding all info for a Dike.
/// </summary>
public class Dike
{
    private readonly List<Soil> databaseSoils = new List<Soil>();
    private IList<Location> locations;

    private IList<Pl1Line> pl1Lines;
    private SoilList soilList;
    private IList<SoilProfile1D> soilProfiles;
    private IList<SoilProfile2D> soilProfiles2D;

    /// <summary>
    /// Initializes a new instance of the <see cref="Dike"/> class.
    /// </summary>
    public Dike()
    {
        Name = "Dijkring";
        
        locations = new List<Location>();
        soilProfiles = new List<SoilProfile1D>();
        soilProfiles2D = new List<SoilProfile2D>();
        SurfaceLines2 = new List<SurfaceLine2>();
        pl1Lines = new List<Pl1Line>();
        soilList = new SoilList();
    }

    public virtual string Name { get; set; }

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

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

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

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

    /// <summary>
    /// Gets or sets the soilprofiles2d.
    /// </summary>
    /// <value>
    /// The soilprofiles2d.
    /// </value>
    public virtual IList<SoilProfile2D> SoilProfiles2D
    {
        get
        {
            return soilProfiles2D;
        }
        set
        {
            soilProfiles2D = value;
        }
    }

    public virtual SoilList SoilList
    {
        get
        {
            return soilList;
        }
        set
        {
            soilList = value;
        }
    }
    
    /// <summary>
    /// Gets or sets the degree of consolidation per material due to the traffic load.
    /// </summary>
    public virtual IList<TrafficLoadDegreeOfConsolidation> TrafficLoadDegreeOfConsolidations { get; set; }

    [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
    {
        get
        {
            return GaugePlLines != null && GaugePlLines.Count > 0 && Gauges != null;
        }
    }

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

    /// <summary>
    /// Gets or sets the input time serie collection.
    /// </summary>
    /// <value>
    /// Input time series for operational use
    /// </value>
    public TimeSerieCollection InputTimeSerieCollection { get; set; } = null;

    /// <summary>
    /// For all locations, clears all the scenarios except for the first one.
    /// </summary>
    public void ClearLocationScenariosExceptFirst()
    {
        foreach (Location location in Locations)
        {
            DesignScenario scenario = location.Scenarios[0].CloneInput();
            location.Scenarios.Clear();
            location.Scenarios.Add(scenario);
        }
    }

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

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

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

            if (location.Scenarios.Count < 1)
            {
                throw new DikeException("Location " + location.Name + " has no scenarios, at least one scenario is required.");
            }

            ValidateLocationForOperational(isOperational, location);
        }
    }

    private static void ValidateLocationForOperational(bool isOperational, Location location)
    {
        if (!isOperational)
        {
            return;
        }

        if (location.Scenarios.Count > 1)
        {
            throw new DikeException($"For Operational (DamLive), location {location.Name} has {location.Scenarios.Count} scenarios but only one is allowed!");
        }

        if ((location.SensorLocation != null) && location.SensorLocation.SensorGroup.SensorArray.Any(sensorArray => sensorArray.RelativeLocation < 0))
        {
            throw new DikeException($"For Operational (DamLive), location {location.Name} has sensor which are not relative to the starting point.");
        }
    }

    private static void ValidateLocationForPiping(bool isPiping, Location location)
    {
        if (!isPiping)
        {
            return;
        }

        if (location.Segment == null)
        {
            throw new DikeException(string.Format(Resources.LocationHasNoSegmentDefined, location.Name));
        }

        if (location.Segment.SoilProfileProbabilities.Count < 1)
        {
            throw new DikeException(string.Format(Resources.LocationHasNoSoilProfilesDefined, location.Name));
        }

        if (location.Segment.SoilProfileProbabilities[0].SoilProfile2D != null)
        {
            throw new DikeException(Resources.PipingWith2DGeometryIsNotSupported);
        }
    }

    /// <summary>
    /// Adapt data so it is consistent
    /// </summary>
    public List<LogMessage> MakeDataConsistent()
    {
        List<Soil> errorSoils = TryToMakeSoilDataConsistent();
        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 database and so have no parameters.
        logMessages.AddRange(DeleteLocationsWithProfilesWithUnknownSoils(errorSoils));
        return logMessages;
    }

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

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

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

    public override string ToString()
    {
        return Name;
    }

    /// <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>
    /// <returns></returns>
    private List<Soil> TryToMakeSoilDataConsistent()
    {
        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 = databaseSoils.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 databaseSoils)
        {
            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.SoilProfile1D.Layers.Find(l => String.Equals(l.Soil.Name, invalidSoil.Name, StringComparison.CurrentCultureIgnoreCase));

                if (fl != null)
                {
                    soilProf = spp.SoilProfile1D.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.SurfaceLine != null));

        // Report which locations are not added because no valid surfaceline is found
        var deletedLocations = new List<Location>();
        deletedLocations.AddRange(Locations.Where(loc => loc.SurfaceLine == 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;
    }
}