// Copyright (C) Stichting Deltares 2019. 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 System.Resources;
using System.Reflection;
using System.Globalization;

namespace Deltares.Dam.Data
{

    /// <summary>
    /// Declares the string resource names
    /// </summary>
    internal enum StringResourceNames
    {
        CsvFileNotFound,
        CsvFileNotValid,
        CsvHeaderNullOrEmpty,
        CsvHeaderNotValid,
        CsvObjectMaterializerNotValid,
        CsvSplitterPatternNotValid,
        DataImportArgumentNull,
        EntityAlreadyExist,
        EntityFactoryArgumentNull,
        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()
        {
            this.resources = new ResourceManager("Deltares.Dam.Data.Properties.Resources", Assembly.GetExecutingAssembly());
        }

        /// <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>
        /// 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)
        {
            var loader = GetInstance();
            if (loader == null)
            {
                return null;
            }
            return loader.resources.GetString(name, CultureInfo.CurrentCulture);
        }
    }

    /// <summary>
    /// 
    /// </summary>
    internal static class ThrowHelper
    {
        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), String.Format("{0} in {1}", (fileName ?? ""), 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();
        }       

        public static void ThrowWhenConditionIsTrue<TException>(string message, Func<bool> condition)
            where TException : Exception
        {
            var exception = (Exception)Activator.CreateInstance(typeof(TException), new object[] { message });

            if (condition())
                throw exception;
        }

        internal static void ThrowWhenConditionIsTrue<TException>(StringResourceNames resourceName, Func<bool> condition)
            where TException : Exception
        {
            var exception = (Exception)Activator.CreateInstance(
                typeof(TException), new object[] { 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
        {
            var exception = exceptionFactory(resourceName);
            if (condition(arg))
                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)
        {
            var pi = owner.GetType().GetProperty(propertyName);
            var 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()
        {
            var entity = lookup.FirstOrDefault(predicate);
            if (Equals(entity, default(T)))
            {
                throw new RequiredEntityNotExistException(
                    GetResourceString(StringResourceNames.RequiredEntityDoesNotExist),
                    typeof(T),
                    id);
            }
            return entity;
        }
    }
}