using System;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Creation;
using Chernobyl.Generation.Old;

namespace Chernobyl.Generation
{
    /// <summary>
    /// The representation of a data set which has some recurring data.
    /// </summary>
    public interface IPattern : IComparable<IPattern>
    {
        /// <summary>
        /// The pattern's data set.
        /// </summary>
        IEnumerable<double> Data { get; }

        /// <summary>
        /// The average value of the <see cref="Data"/>.
        /// </summary>
        double Average { get; }
    }

    /// <summary>
    /// Represents multiple <see cref="IPattern"/> instances as a single <see cref="IPattern"/>.
    /// </summary>
    public interface ICompositePattern : IPattern
    {
        /// <summary>
        /// The <see cref="IPattern"/> this instance is composed of.
        /// </summary>
        IEnumerable<IPattern> Patterns { get; }
    }

    /// <summary>
    /// A simple <see cref="IPattern"/> that just takes its data from the constructor parameter.
    /// </summary>
    public class BasicPattern : IPattern
    {
        /// <ignore />
        public BasicPattern(IEnumerable<double> data)
        {
            Data = data;
        }

        /// <summary>
        /// Creates an <see cref="IPattern"/> with a single value for its data.
        /// </summary>
        public BasicPattern(double data)
            : this(new[] {data})
        {
            Average = Data.Average();
        }

        /// <inheritdoc />
        public int CompareTo(IPattern other)
        {
            return Average.CompareTo(other.Average);
        }

        /// <inheritdoc />
        public IEnumerable<double> Data { get; }

        /// <inheritdoc />
        public double Average { get; }
    }

    /// <inheritdoc />
    public class CompositePattern : ICompositePattern
    {
        /// <inheritdoc />
        public CompositePattern(IEnumerable<IPattern> patterns)
        {
            Patterns = patterns;
            Average = Data.Average();
        }

        /// <inheritdoc />
        public IEnumerable<double> Data => Patterns.SelectMany(pattern => pattern.Data);

        /// <inheritdoc />
        public double Average { get; }

        /// <inheritdoc />
        public IEnumerable<IPattern> Patterns { get; }

        /// <inheritdoc />
        public int CompareTo(IPattern other)
        {
            return Average.CompareTo(other.Average);
        }
    }

    /// <summary>
    /// Initialization properties for creating conflicted <see cref="IPattern"/>.
    /// </summary>
    public class ConflictedPatternConfig
    {
        /// <inheritdoc />
        public ConflictedPatternConfig(int count)
        {
            Count = count;
        }

        /// <summary>
        /// The number of values to build the pattern from. The higher the value, the larger the
        /// pattern size.
        /// </summary>
        public int Count { get; }
    }

    /// <summary>
    /// Creates a conflicted <see cref="IPattern"/>.
    /// </summary>
    public interface IConflictedPatternFactory : IFactory<ConflictedPatternConfig, IPattern> { }

    /// <summary>
    /// An <see cref="IConflictedPatternFactory"/> that creates a <see cref="IPattern"/>.
    /// </summary>
    public class ConflictedPatternFactory : FuncFactory<ConflictedPatternConfig, IPattern>, IConflictedPatternFactory
    {
        /// <inheritdoc />
        public ConflictedPatternFactory() : base(config => Old.Pattern.BuildHierarchy(config.Count, new Random())) { }
    }
}