using System;
using Umbraco.Core.Models;
using Umbraco.Core.Models.PublishedContent;

namespace Umbraco.Core
{
    /// <summary>
    /// Provides extension methods for content variations.
    /// </summary>
    public static class ContentVariationExtensions
    {
        /// <summary>
        /// Determines whether the content type is invariant.
        /// </summary>
        public static bool VariesByNothing(this ISimpleContentType contentType) => contentType.Variations.VariesByNothing();

        /// <summary>
        /// Determines whether the content type varies by culture.
        /// </summary>
        public static bool VariesByCulture(this ISimpleContentType contentType) => contentType.Variations.VariesByCulture();

        /// <summary>
        /// Determines whether the content type is invariant.
        /// </summary>
        public static bool VariesByNothing(this IContentTypeBase contentType) => contentType.Variations.VariesByNothing();

        /// <summary>
        /// Determines whether the content type varies by culture.
        /// </summary>
        /// <remarks>And then it could also vary by segment.</remarks>
        public static bool VariesByCulture(this IContentTypeBase contentType) => contentType.Variations.VariesByCulture();

        /// <summary>
        /// Determines whether the content type varies by segment.
        /// </summary>
        /// <remarks>And then it could also vary by culture.</remarks>
        public static bool VariesBySegment(this IContentTypeBase contentType) => contentType.Variations.VariesBySegment();

        /// <summary>
        /// Determines whether the content type varies by culture and segment.
        /// </summary>
        public static bool VariesByCultureAndSegment(this IContentTypeBase contentType) => contentType.Variations.VariesByCultureAndSegment();

        /// <summary>
        /// Determines whether the property type is invariant.
        /// </summary>
        public static bool VariesByNothing(this PropertyType propertyType) => propertyType.Variations.VariesByNothing();

        /// <summary>
        /// Determines whether the property type varies by culture.
        /// </summary>
        /// <remarks>And then it could also vary by segment.</remarks>
        public static bool VariesByCulture(this PropertyType propertyType) => propertyType.Variations.VariesByCulture();

        /// <summary>
        /// Determines whether the property type varies by segment.
        /// </summary>
        /// <remarks>And then it could also vary by culture.</remarks>
        public static bool VariesBySegment(this PropertyType propertyType) => propertyType.Variations.VariesBySegment();

        /// <summary>
        /// Determines whether the property type varies by culture and segment.
        /// </summary>
        public static bool VariesByCultureAndSegment(this PropertyType propertyType) => propertyType.Variations.VariesByCultureAndSegment();

        /// <summary>
        /// Determines whether the content type is invariant.
        /// </summary>
        public static bool VariesByNothing(this IPublishedContentType contentType) => contentType.Variations.VariesByNothing();

        /// <summary>
        /// Determines whether the content type varies by culture.
        /// </summary>
        /// <remarks>And then it could also vary by segment.</remarks>
        public static bool VariesByCulture(this IPublishedContentType contentType) => contentType.Variations.VariesByCulture();

        /// <summary>
        /// Determines whether the content type varies by segment.
        /// </summary>
        /// <remarks>And then it could also vary by culture.</remarks>
        public static bool VariesBySegment(this IPublishedContentType contentType) => contentType.Variations.VariesBySegment();

        /// <summary>
        /// Determines whether the content type varies by culture and segment.
        /// </summary>
        public static bool VariesByCultureAndSegment(this IPublishedContentType contentType) => contentType.Variations.VariesByCultureAndSegment();

        /// <summary>
        /// Determines whether the property type is invariant.
        /// </summary>
        public static bool VariesByNothing(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesByNothing();

        /// <summary>
        /// Determines whether the property type varies by culture.
        /// </summary>
        public static bool VariesByCulture(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesByCulture();

        /// <summary>
        /// Determines whether the property type varies by segment.
        /// </summary>
        public static bool VariesBySegment(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesBySegment();

        /// <summary>
        /// Determines whether the property type varies by culture and segment.
        /// </summary>
        public static bool VariesByCultureAndSegment(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesByCultureAndSegment();

        /// <summary>
        /// Determines whether a variation is invariant.
        /// </summary>
        public static bool VariesByNothing(this ContentVariation variation) => variation == ContentVariation.Nothing;

        /// <summary>
        /// Determines whether a variation varies by culture.
        /// </summary>
        /// <remarks>And then it could also vary by segment.</remarks>
        public static bool VariesByCulture(this ContentVariation variation) => (variation & ContentVariation.Culture) > 0;

        /// <summary>
        /// Determines whether a variation varies by segment.
        /// </summary>
        /// <remarks>And then it could also vary by culture.</remarks>
        public static bool VariesBySegment(this ContentVariation variation) => (variation & ContentVariation.Segment) > 0;

        /// <summary>
        /// Determines whether a variation varies by culture and segment.
        /// </summary>
        public static bool VariesByCultureAndSegment(this ContentVariation variation) => (variation & ContentVariation.CultureAndSegment) == ContentVariation.CultureAndSegment;

        /// <summary>
        /// Validates that a combination of culture and segment is valid for the variation.
        /// </summary>
        /// <param name="variation">The variation.</param>
        /// <param name="culture">The culture.</param>
        /// <param name="segment">The segment.</param>
        /// <param name="exact">A value indicating whether to perform exact validation.</param>
        /// <param name="wildcards">A value indicating whether to support wildcards.</param>
        /// <param name="throwIfInvalid">A value indicating whether to throw a <see cref="NotSupportedException"/> when the combination is invalid.</param>
        /// <returns>True if the combination is valid; otherwise false.</returns>
        /// <remarks>
        /// <para>When validation is exact, the combination must match the variation exactly. For instance, if the variation is Culture, then
        /// a culture is required. When validation is not strict, the combination must be equivalent, or more restrictive: if the variation is
        /// Culture, an invariant combination is ok.</para>
        /// <para>Basically, exact is for one content type, or one property type, and !exact is for "all property types" of one content type.</para>
        /// <para>Both <paramref name="culture"/> and <paramref name="segment"/> can be "*" to indicate "all of them".</para>
        /// </remarks>
        /// <exception cref="NotSupportedException">Occurs when the combination is invalid, and <paramref name="throwIfInvalid"/> is true.</exception>
        public static bool ValidateVariation(this ContentVariation variation, string culture, string segment, bool exact, bool wildcards, bool throwIfInvalid)
        {
            culture = culture.NullOrWhiteSpaceAsNull();
            segment = segment.NullOrWhiteSpaceAsNull();

            // if wildcards are disabled, do not allow "*"
            if (!wildcards && (culture == "*" || segment == "*"))
            {
                if (throwIfInvalid)
                    throw new NotSupportedException($"Variation wildcards are not supported.");
                return false;
            }

            if (variation.VariesByCulture())
            {
                // varies by culture
                // in exact mode, the culture cannot be null                
                if (exact && culture == null)
                {
                    if (throwIfInvalid)
                        throw new NotSupportedException($"Culture may not be null because culture variation is enabled.");
                    return false;
                }    
            }
            else
            {
                // does not vary by culture
                // the culture cannot have a value
                // unless wildcards and it's "*"
                if (culture != null && !(wildcards && culture == "*"))
                {
                    if (throwIfInvalid)
                        throw new NotSupportedException($"Culture \"{culture}\" is invalid because culture variation is disabled.");
                    return false;
                }
            }          

            // if it does not vary by segment
            // the segment cannot have a value
            // segment may always be null, even when the ContentVariation.Segment flag is set for this variation,
            // therefore the exact parameter is not used in segment validation.
            if (!variation.VariesBySegment() && segment != null && !(wildcards && segment == "*"))
            {
                if (throwIfInvalid)
                    throw new NotSupportedException($"Segment \"{segment}\" is invalid because segment variation is disabled.");
                return false;
            }

            return true;
        }
    }
}