// 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.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;

namespace Deltares.Dam.Data;

/// <summary>
/// Declares the string resource names
/// </summary>
internal enum StringResourceNames
{
    CsvFileNotFound,
    CsvFileNotValid,
    CsvHeaderNullOrEmpty,
    CsvHeaderNotValid,
    CsvObjectMaterializerNotValid,
    CsvSplitterPatternNotValid,
    DataImportArgumentNull,
    ImportFileNotExist,
    ImportFolderNotExist,
    ImportFolderNullOrEmpty,
    MStabExecutableFileNameNotFound,
    SlopeWExecutableFileNameNotFound,
    OutputFileNotExist,
    OutputFileHasNoContent,
    OutputFileNameNotValid,
    ProjectFileNameNullOrEmpty,
    ProjectFileNotExist,
    SegmentIdArgumentNullOrEmpty,
    SoilProfileIdArgumentNullOrEmpty,
    SurfaceLineIdArgumentNullOrEmpty,
    RequiredEntityDoesNotExist,
    ImportFilesNotValidated,
    RequiredParameterMissing,
    SurfacelineIsNotInsideSoilprofile,
    TopLayerToBeEvaluatedNotInsideSoilprofile,
    SoilAttachedToLayerNotValid,
    ImportDataNotValid,
    ImportedLocationDoesntHaveValidSurfaceLines,
    ImportedLocationDoesntHaveValidPL1Lines,
    SurfaceLinePointNotExtists,
    NonExistentLocation,
    TwoSandlayersRequiredInSoilProfile,
    CsvColumnIndexAlreadyExists,
    WaterLevelInputFileNullOrEmpty,
    NoSoilProfileDefinedForLocation,
    LocationHasNoSegment,
    FileNameNotValid,
    GaugeIdArgumentNullOrEmpty,
    LocationIdArgumentNullOrEmpty,
    ImportedLocationDoesntHaveSoilprofile,
    SoildatabaseNotFound,
    SurfaceLineNotAssigned,
    SoilProfileNotAssigned,
    SoilListIsNull,
    PL1NotCreated,
    NoDikeDefined,
    NoLocationsDefined,
    NoCalculationTypeSpecified,
    NoScenariosDefinedInLocation,
    NoRiverLevel,
    NoSurfaceLines,
    NoSoilsDefinedInProject,
    NoSoilprofiles1DDefinedInProject
}

/// <summary>
/// Defines a helper class for getting string resources
/// </summary>
/// <remarks>
/// The class implements a singleton pattern
/// </remarks>
internal class StringResources
{
    /// <summary>
    /// Holds a single reference to this class
    /// </summary>
    private static StringResources instance;

    /// <summary>
    /// The sync method for making this class thread safe
    /// </summary>
    private static readonly object sync = new object();

    /// <summary>
    /// The actual resource manager
    /// </summary>
    private readonly ResourceManager resources;

    // Methods
    internal StringResources()
    {
        resources = new ResourceManager("Deltares.Dam.Data.Properties.Resources", Assembly.GetExecutingAssembly());
    }

    /// <summary>
    /// Getst the string from the from the resource manager
    /// </summary>
    /// <param name="name">The name of the resource</param>
    /// <returns>The resource string</returns>
    public static string GetString(string name)
    {
        StringResources loader = GetInstance();
        if (loader == null)
        {
            return null;
        }

        return loader.resources.GetString(name, CultureInfo.CurrentCulture);
    }

    /// <summary>
    /// Gets the sinlgeton instance 
    /// </summary>
    /// <returns>A reference to this class instance</returns>
    private static StringResources GetInstance()
    {
        if (instance == null)
        {
            lock (sync)
            {
                if (instance == null)
                {
                    instance = new StringResources();
                }
            }
        }

        return instance;
    }
}

/// <summary>
/// 
/// </summary>
internal static class ThrowHelper
{
    public static void ThrowWhenConditionIsTrue<TException>(string message, Func<bool> condition)
        where TException : Exception
    {
        var exception = (Exception) Activator.CreateInstance(typeof(TException), message);

        if (condition())
        {
            throw exception;
        }
    }

    public static void ThrowWhenParameterIsMissing(object owner, string parameterName, object parameterValue)
    {
        if (parameterValue == null)
        {
            throw new ParameterMissingException(
                string.Format(GetResourceString(StringResourceNames.RequiredParameterMissing), parameterName, owner.GetType().Name));
        }
    }

    public static void ThrowWhenParameterIsMissing(object owner, string propertyName)
    {
        PropertyInfo pi = owner.GetType().GetProperty(propertyName);
        object propertyValue = pi.GetValue(owner, null);

        if (propertyValue == null)
        {
            throw new ParameterMissingException(
                string.Format(GetResourceString(StringResourceNames.RequiredParameterMissing), propertyName, owner.GetType().Name));
        }
    }

    public static void ThrowWhenRequiredEntityDoesntExistInLookup<T>(object id) where T : new()
    {
        throw new RequiredEntityNotExistException(
            GetResourceString(StringResourceNames.RequiredEntityDoesNotExist),
            typeof(T),
            id);
    }

    public static T ThrowWhenRequiredEntityDoesntExistInLookup<T>(IEnumerable<T> lookup, object id, Func<T, bool> predicate) where T : new()
    {
        T entity = lookup.FirstOrDefault(predicate);
        if (Equals(entity, default(T)))
        {
            throw new RequiredEntityNotExistException(
                GetResourceString(StringResourceNames.RequiredEntityDoesNotExist),
                typeof(T),
                id);
        }

        return entity;
    }

    internal static string GetResourceString(StringResourceNames resourceNames)
    {
        return StringResources.GetString(resourceNames.ToString());
    }

    internal static void ThrowIfArgumentNull(object value, string parameter, StringResourceNames resourceNamesName)
    {
        if (value == null)
        {
            throw new ArgumentNullException(parameter, GetResourceString(resourceNamesName));
        }
    }

    internal static void ThrowIfArgumentNull(object value, string parameter, string message)
    {
        if (value == null)
        {
            throw new ArgumentNullException(parameter, message);
        }
    }

    internal static void ThrowIfStringArgumentNullOrEmpty(string value, StringResourceNames resourceNamesName)
    {
        if (string.IsNullOrEmpty(value) || value.Trim() == "")
        {
            throw new ArgumentException(GetResourceString(resourceNamesName));
        }
    }

    internal static void ThrowIfFileNameNullOrEmpty(string fileName)
    {
        ThrowIfFileNameNullOrEmpty(fileName, StringResourceNames.FileNameNotValid);
    }

    internal static void ThrowIfFileNameNullOrEmpty(string fileName, StringResourceNames resourceName)
    {
        ThrowIfFileNameNullOrEmpty<ArgumentNullException>(fileName, resourceName);
    }

    internal static void ThrowIfFileNameNullOrEmpty<TException>(string fileName, StringResourceNames resourceName)
        where TException : Exception
    {
        ThrowWhenConditionIsTrue<TException>(resourceName,
                                             () => string.IsNullOrEmpty(fileName) || fileName.Trim() == "");
    }

    internal static void ThrowIfFileNotExist(string fileName, StringResourceNames resourceNamesName)
    {
        if (!File.Exists(fileName))
        {
            throw new FileNotFoundException(string.Format(GetResourceString(resourceNamesName), $"{(fileName ?? "")} in {DamProject.ProjectWorkingPath}"));
        }
    }

    internal static void ThrowIfDirectoryNotExist(string dirName, StringResourceNames resourceNamesName)
    {
        if (!Directory.Exists(dirName))
        {
            throw new DirectoryNotFoundException(string.Format(GetResourceString(resourceNamesName), dirName ?? "supplied"));
        }
    }

    internal static void ThrowWhenConditionIsTrue<TException>(Func<bool> condition, Func<TException> exceptionFactory)
        where TException : Exception
    {
        if (condition())
        {
            throw exceptionFactory();
        }
    }

    internal static void ThrowWhenConditionIsTrue<TException>(StringResourceNames resourceName, Func<bool> condition)
        where TException : Exception
    {
        var exception = (Exception) Activator.CreateInstance(
            typeof(TException), GetResourceString(resourceName));

        if (condition())
        {
            throw exception;
        }
    }

    internal static void ThrowWhenConditionIsTrue<TException, TArgument>(TArgument arg, StringResourceNames resourceName,
                                                                         Func<TArgument, bool> condition, Func<StringResourceNames, TException> exceptionFactory)
        where TException : Exception
    {
        TException exception = exceptionFactory(resourceName);
        if (condition(arg))
        {
            throw exception;
        }
    }
}