// 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.IO;
using System.Linq;
using Deltares.Dam.StixFileReader;
using Deltares.Geotechnics.Soils;
using Deltares.Standard.Language;

namespace Deltares.Dam.Data.Geometry2DImporter;

/// <summary>
/// Importer to import <see cref="SoilProfile2D" />.
/// </summary>
public static class SoilProfile2DImporter
{
    /// <summary>
    /// Imports the <see cref="SoilProfile2D" /> that are contained within <paramref name="segment" />.
    /// </summary>
    /// <param name="soilProfileDirectory">The directory to retrieve the soil profiles from.</param>
    /// <param name="segment">The <see cref="Segment" /> to import the soil profiles for.</param>
    /// <param name="availableSoils">The <see cref="SoilList" /> that contains all the valid soil materials.</param>
    /// <param name="aquifers">The collection of <see cref="Aquifer"/> that is imported from csv.></param>
    /// <param name="xSoilGeometry2DOrigin"></param>
    /// <returns>A collection of <see cref="SoilProfile2D" />.</returns>
    /// <exception cref="ArgumentNullException"> Thrown when <paramref name="segment" /> or <paramref name="availableSoils" /> is <c>null</c>.
    /// </exception>
    /// <exception cref="ArgumentException"> Thrown when <paramref name="soilProfileDirectory" />
    /// is <c>null</c>, empty or consist of only whitespaces.
    /// </exception>
    /// <exception cref="SoilProfileImporterException">Thrown when the soil profiles could not be successfully imported.</exception>
    public static IEnumerable<SoilProfile2D> Import(string soilProfileDirectory, Segment segment, SoilList availableSoils,
                                                    IEnumerable<Aquifer> aquifers, double xSoilGeometry2DOrigin = 0.0)
    {
        if (segment == null)
        {
            throw new ArgumentNullException(nameof(segment));
        }

        if (availableSoils == null)
        {
            throw new ArgumentNullException(nameof(availableSoils));
        }

        if (string.IsNullOrWhiteSpace(soilProfileDirectory))
        {
            throw new ArgumentException($"'{nameof(soilProfileDirectory)}' cannot be null or consist of whitespaces only.");
        }

        // Extract all soil profile 2D from a segment
        IEnumerable<SoilGeometryProbability> soilProfiles = segment.SoilProfileProbabilities.Where(sp => sp.SoilProfileType == SoilProfileType.SoilProfile2D);

        var importedSoilProfiles = new List<SoilProfile2D>();
        foreach (SoilGeometryProbability profile in soilProfiles)
        {
            string profileName = profile.SoilGeometry2DName;
            SoilProfile2D importedSoilProfile = ReadSoilProfile(soilProfileDirectory, profileName, aquifers, xSoilGeometry2DOrigin);
            foreach (string soilName in importedSoilProfile.Surfaces.Select(surface => surface.Soil.Name))
            {
                if (!IsSoilOfSurfacePresent(availableSoils.Soils, soilName))
                {
                    string messageFormat = LocalizationManager.GetTranslatedText(typeof(SoilProfile2DImporter), "ImportSoilProfileErrorUndefinedMaterials");
                    throw new SoilProfileImporterException(string.Format(messageFormat, profileName, soilName));
                }
            }

            TransferSoilLayerProperties(importedSoilProfile.Surfaces);
            importedSoilProfiles.Add(importedSoilProfile);
        }

        return importedSoilProfiles;
    }

    /// <summary>
    /// Reads a soil profile.
    /// </summary>
    /// <param name="soilProfileDirectory">The directory to read the <see cref="SoilProfile2D"/> from.</param>
    /// <param name="soilProfileName">The name of the soil profile.</param>
    /// <param name="aquifers">The collection of <see cref="Aquifer"/> that is imported from csv.></param>
    /// <param name="xSoilGeometry2DOrigin"></param>
    /// <returns>A <see cref="SoilProfile2D"/>.</returns>
    /// <exception cref="SoilProfileImporterException">Thrown when the soil profile could not be read.</exception>
    private static SoilProfile2D ReadSoilProfile(string soilProfileDirectory, string soilProfileName,
                                                 IEnumerable<Aquifer> aquifers, double xSoilGeometry2DOrigin)
    {
        string soilProfileFileName = StixFileReaderHelper.FetchFileNameWithStixExtension(soilProfileName);
        string filePath = Path.Combine(soilProfileDirectory, soilProfileFileName);
        if (File.Exists(filePath))
        {
            filePath = Path.Combine(soilProfileDirectory, soilProfileFileName);
            try
            {
                SoilProfile2D readSoilProfile = null;
                var reader = new StixFileReader.StixFileReader();
                readSoilProfile = reader.ReadSoilProfile(filePath, xSoilGeometry2DOrigin);
                TransferAquiferData(soilProfileFileName, readSoilProfile.Surfaces, aquifers);

                return readSoilProfile;
            }
            catch (StixFileReadException e)
            {
                string messageFormat = LocalizationManager.GetTranslatedText(typeof(SoilProfile2DImporter), "ImportSoilProfileErrorReadFailed");
                throw new SoilProfileImporterException(string.Format(messageFormat, soilProfileName, e.Message), e);
            }
        }

        string message = LocalizationManager.GetTranslatedText(typeof(SoilProfile2DImporter), "ImportSoilProfileErrorReadFailed");
        throw new SoilProfileImporterException(string.Format(message, soilProfileName, string.Empty));
    }

    private static bool IsSoilOfSurfacePresent(IEnumerable<Soil> availableSoils, string soilName)
    {
        var soilNames = new HashSet<string>(availableSoils.Select(s => s.Name));
        return soilNames.Contains(soilName, StringComparer.OrdinalIgnoreCase);
    }

    private static void TransferSoilLayerProperties(IEnumerable<SoilLayer2D> soilLayers)
    {
        foreach (SoilLayer2D layer in soilLayers)
        {
            layer.WaterpressureInterpolationModel = WaterpressureInterpolationModel.Hydrostatic;
        }
    }

    private static void TransferAquiferData(string soilProfileFileName, IEnumerable<SoilLayer2D> soilLayers, IEnumerable<Aquifer> aquifers)
    {
        if (aquifers != null && aquifers.Any())
        {
            List<Aquifer> aquiferList = aquifers.ToList();
            foreach (SoilLayer2D layer in soilLayers)
            {
                Aquifer aquifer = aquiferList.Find(a => a.StixFileName == soilProfileFileName && a.LayerName == layer.GeometrySurface.Name);
                if (aquifer != null)
                {
                    layer.IsAquifer = true;
                }
            }
        }
    }
}