using System;
using System.Collections;
using System.Linq;
using Chernobyl.Collections.Generic;
using JetBrains.Annotations;

namespace Chernobyl
{
    /// <summary>
    /// Instance used to validate parameters or other values.
    /// </summary>
    /// <typeparam name="T">The type being validated.</typeparam>
    public struct Validater<T>
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="value">The value to validate.</param>
        /// <param name="name">The name of the <paramref name="value"/> parameter. This is used
        /// in the exception message to make the message easier to understand.</param>
        public Validater(T value, string name)
        {
            Value = value;
            Name = name;
        }

        /// <summary>
        /// The value to validate.
        /// </summary>
        public T Value { get; }

        /// <summary>
        /// The name of the <see cref="Value"/> parameter. This is used in the exception message to
        /// make the message easier to understand.
        /// </summary>
        public string Name { get; }
    }

    /// <summary>
    /// Validates reference type instances.
    /// </summary>
    public static class ReferenceValidater
    {
        /// <summary>
        /// Throws an <see cref="ArgumentNullException"/> if <see cref="Validater{T}.Value"/> is null.
        /// </summary>
        /// <param name="validator">The instance containing the value to validate.</param>
        /// <returns>The <c>this</c> instance.</returns>
        public static Validater<T> IfNull<T>(this Validater<T> validator)
            where T : class
        {
            if (validator.Value == null)
                throw new ArgumentNullException(validator.Name, "Argument cannot be null. Please provide a valid value.");

            return validator;
        }

        /// <summary>
        /// Throws an <see cref="ArgumentNullException"/> if <paramref name="param"/> is null. Does
        /// the same thing as <code>param.Throw(paramName).IfNull()</code>.
        /// </summary>
        /// <typeparam name="T">The type of the parameter. This type must be a reference type.</typeparam>
        /// <param name="param">The instance to check.</param>
        /// <param name="paramName">The name of the parameter that caused the exception, if any.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="param"/> is null.</exception>
        [ContractAnnotation("param:null => halt")]
        public static Validater<T> ThrowIfNull<T>([NoEnumeration, CanBeNull]this T param, string paramName)
            where T : class => param.Throw(paramName).IfNull();
    }

    /// <summary>
    /// Validates <see cref="IComparable{T}"/> instances.
    /// </summary>
    public static class ComparableValidater
    {
        /// <summary>
        /// Throws an <see cref="ArgumentOutOfRangeException"/> if <see cref="Validater{T}.Value"/> is less
        /// than <paramref name="lessThan"/>.
        /// </summary>
        /// <param name="validator">The instance containing the value to validate.</param>
        /// <param name="lessThan">The value to compare against.</param>
        /// <param name="name">The name of the value comparing against or an empty string if it has
        /// no name.</param>
        /// <returns>The <c>this</c> instance.</returns>
        public static Validater<T> IfLessThan<T>(this Validater<T> validator, T lessThan, string name = "")
            where T : IComparable<T>
        {
            if (validator.Value.CompareTo(lessThan) < 0)
            {
                var otherName = name.IsEmptyOrNull() ? lessThan.ToString() : $"{name} (${lessThan})";
                throw new ArgumentOutOfRangeException(validator.Name, validator.Value, $"{validator.Name} cannot be less than {otherName}.");
            }

            return validator;
        }

        /// <summary>
        /// Throws an <see cref="ArgumentOutOfRangeException"/> if <see cref="Validater{T}.Value"/> is less
        /// than or equal to <paramref name="lessThan"/>.
        /// </summary>
        /// <param name="validator">The instance containing the value to validate.</param>
        /// <param name="lessThan">The value to compare against.</param>
        /// <param name="name">The name of the value comparing against or an empty string if it has
        /// no name.</param>
        /// <returns>The <c>this</c> instance.</returns>
        public static Validater<T> IfLessThanOrEqualTo<T>(this Validater<T> validator, T lessThan, string name = "")
            where T : IComparable<T>
        {
            if (validator.Value.CompareTo(lessThan) <= 0)
            {
                var otherName = name.IsEmptyOrNull() ? lessThan.ToString() : $"{name} (${lessThan})";
                throw new ArgumentOutOfRangeException(validator.Name, validator.Value, $"{validator.Name} cannot be less than or equal to {otherName}.");
            }

            return validator;
        }

        /// <summary>
        /// Throws an <see cref="ArgumentOutOfRangeException"/> if <see cref="Validater{T}.Value"/> is greater
        /// than <paramref name="greaterThan"/>.
        /// </summary>
        /// <param name="validator">The instance containing the value to validate.</param>
        /// <param name="greaterThan">The value to compare against.</param>
        /// <param name="name">The name of the value comparing against or an empty string if it has
        /// no name.</param>
        /// <returns>The <c>this</c> instance.</returns>
        public static Validater<T> IfGreaterThan<T>(this Validater<T> validator, T greaterThan, string name = "")
            where T : IComparable<T>
        {
            if (validator.Value.CompareTo(greaterThan) > 0)
            {
                var otherName = name.IsEmptyOrNull() ? greaterThan.ToString() : $"{name} (${greaterThan})";
                throw new ArgumentOutOfRangeException(validator.Name, validator.Value, $"{validator.Name} cannot be greater than {otherName}.");
            }

            return validator;
        }

        /// <summary>
        /// Throws an <see cref="ArgumentOutOfRangeException"/> if <see cref="Validater{T}.Value"/> is greater
        /// than or equal to <paramref name="other"/>.
        /// </summary>
        /// <param name="validator">The instance containing the value to validate.</param>
        /// <param name="other">The value to compare against.</param>
        /// <param name="name">The name of the value comparing against or an empty string if it has
        /// no name.</param>
        /// <returns>The <c>this</c> instance.</returns>
        public static Validater<T> IfGreaterThanOrEqualTo<T>(this Validater<T> validator, T other, string name = "")
            where T : IComparable<T>
        {
            if (validator.Value.CompareTo(other) >= 0)
            {
                var otherName = name.IsEmptyOrNull() ? other.ToString() : $"{name} (${other})";
                throw new ArgumentOutOfRangeException(validator.Name, validator.Value, $"{validator.Name} cannot be greater than or equal to {otherName}.");
            }

            return validator;
        }

        /// <summary>
        /// Throws an <see cref="ArgumentOutOfRangeException"/> if <see cref="Validater{T}.Value"/>
        /// is not equal to or between <paramref name="lessThan"/> and <paramref name="greaterThan"/>.
        /// </summary>
        /// <param name="validator">The instance containing the value to validate.</param>
        /// <param name="lessThan">The inclusive lower limit.</param>
        /// <param name="greaterThan">The inclusive upper limit.</param>
        /// <returns>The <c>this</c> instance.</returns>
        public static Validater<T> IfNotBetween<T>(this Validater<T> validator, T lessThan, T greaterThan)
            where T : IComparable<T> => validator.IfLessThan(lessThan).IfGreaterThan(greaterThan);
    }

    /// <summary>
    /// Validates <see cref="IEnumerable"/> instances.
    /// </summary>
    public static class EnumerableValidater
    {
        /// <summary>
        /// Throws an exception if the provided <see cref="IEnumerable"/> contains nothing.
        /// </summary>
        public static Validater<T> IfEmpty<T>(this Validater<T> validator) where T : IEnumerable
        {
            // ReSharper disable PossibleMultipleEnumeration
            if (!validator.Value.Cast<object>().Any())
                throw new ArgumentException($"{validator.Name} cannot be empty.", validator.Name);
            return validator;
            // ReSharper restore PossibleMultipleEnumeration
        }


        /// <summary>
        /// Throws an <see cref="ArgumentNullException"/> if <see cref="Validater{T}.Value"/> is null or empty.
        /// </summary>
        /// <param name="validator">The instance containing the value to validate.</param>
        /// <returns>The <c>this</c> instance.</returns>
        public static Validater<T> IfNullOrEmpty<T>(this Validater<T> validator)
            where T : class, IEnumerable => validator.IfNull().IfEmpty();

        /// <summary>
        /// Throws an <see cref="ArgumentNullException"/> if <paramref name="param"/> is null. Does
        /// the same thing as <code>param.Throw(paramName).IfNullOrEmpty()</code>.
        /// </summary>
        /// <typeparam name="T">The type of the parameter. This type must be a reference type.</typeparam>
        /// <param name="param">The instance to check.</param>
        /// <param name="paramName">The name of the parameter that caused the exception, if any.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="param"/> is null.</exception>
        [ContractAnnotation("param:null => halt")]
        public static Validater<T> ThrowIfEmptyOrNull<T>([NoEnumeration, CanBeNull]this T param, string paramName)
            where T : class, IEnumerable => param.Throw(paramName).IfNullOrEmpty();
    }

    /// <summary>
    /// Methods for easier validation of parameters.
    /// </summary>
    public static class Validater
    {
        /// <summary>
        /// Creates the <see cref="Validater{T}"/> from the <paramref name="value"/> provided.
        /// </summary>
        /// <typeparam name="T">The type being validated.</typeparam>
        /// <param name="value">The value to validate.</param>
        /// <param name="name">The name of the <paramref name="value"/> parameter. This is used
        /// in the exception message to make the message easier to understand.</param>
        public static Validater<T> Throw<T>(this T value, string name) => new Validater<T>(value, name);
    }
}