// Copyright (C) Stichting Deltares 2020. All rights reserved.
//
// This file is part of the application DAM - Clients Library.
//
// 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.Geotechnics.Soils;
using Deltares.Standard.Language;

namespace Deltares.Dam.Data.StiImporter
{
    /// <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>
        /// <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)
        {
            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
            var soilProfiles = segment.SoilProfileProbabilities
                .Where(sp => sp.SoilProfileType == SoilProfileType.SoilGeometryStiFile);

            var importedSoilProfiles = new List<SoilProfile2D>();
            foreach (SoilGeometryProbability profile in soilProfiles)
            {
                string profileName = profile.SoilGeometry2DName;
                SoilProfile2D readSoilProfile = ReadSoilProfile(soilProfileDirectory, profileName);
                if (!IsValidSoilProfile(availableSoils, readSoilProfile))
                {
                    string messageFormat = LocalizationManager.GetTranslatedText(typeof(SoilProfile2DImporter), "ImportSoilProfileErrorUndefinedMaterials");
                    throw new SoilProfileImporterException(string.Format(messageFormat, profileName));
                }

                TransferSoilLayerProperties(availableSoils, readSoilProfile.Surfaces);
                importedSoilProfiles.Add(readSoilProfile);
            }

            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>
        /// <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)
        {
            string soilProfileFileName = HasStiFileExtension(soilProfileName) ? soilProfileName : $"{soilProfileName}.sti";
            string filePath = Path.Combine(soilProfileDirectory, soilProfileFileName);
            try
            {
                var reader = new StiFileReader();
                SoilProfile2D readSoilProfile = reader.ReadSoilProfile(filePath);
                readSoilProfile.Name = soilProfileName;

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

        private static bool HasStiFileExtension(string profileName)
        {
            return string.Equals(Path.GetExtension(profileName), ".sti", StringComparison.OrdinalIgnoreCase);
        }

        private static bool IsValidSoilProfile(SoilList availableSoils, SoilProfile2D profile)
        {
            var soilNames = new HashSet<string>(availableSoils.Soils.Select(s => s.Name));
            return profile.Surfaces.All(soilLayer => soilNames.Contains(soilLayer.Name));
        }

        private static void TransferSoilLayerProperties(SoilList availableSoils, IEnumerable<SoilLayer2D> soilLayers)
        {
            foreach (SoilLayer2D layer in soilLayers)
            {
                Soil soil = availableSoils.Soils.Single(s => string.Equals(s.Name, layer.Name));
                layer.IsAquifer = availableSoils.AquiferDictionary[soil];
                layer.WaterpressureInterpolationModel = WaterpressureInterpolationModel.Hydrostatic;
            }
        }
    }
}