using System;

using System.IO;

using System.Collections.Generic;

using System.Linq;

​

namespace Rextester{

    public class Constants {

        public const int MAX_IMAGE_WIDTH = 1920;

        public const int VARIATIONS_INCREMENT = 75;

        public const int MAX_VARIANT_RETURNS = 8;

        public const string OPTIMIZE_MIME = "jpg";

    }

    public class ImageMetaData {

        public int Width {get;set;}

        public int Height {get;set;}

        public string MimeType {get;set;}

    }

    public class VariationInfo {

        public int Width {get;set;}

        public int Height {get;set;}

        public string MimeType {get;set;}

    }

    public class Program{

        public static void Main(string[] args){

            var smallerMetadata = new ImageMetaData {

                Width = 800

            };

            var largerMetadata = new ImageMetaData {

                Width = 4000

            };

            TryOut.GetVariants(largerMetadata, 868, 1299, new VariationInfo[] {});

            TryOut.GetVariants(smallerMetadata, 343, 2000, new VariationInfo[] {});

            TryOut.GetVariants(largerMetadata, 50, 1500, new VariationInfo[] {});

        }

    }

    public static class TryOut {

        public static IEnumerable<VariationInfo> GetVariants(ImageMetaData metaData, int requestedMinWidth, int requestedMaxWidth, IEnumerable<VariationInfo> existingVariants, bool optimize = true)

        {

            if (metaData == null)

                return Enumerable.Empty<VariationInfo>();

​

            var mime = optimize ? Constants.OPTIMIZE_MIME : metaData.MimeType;

            int maxImageSize;

​

            if( metaData?.Width == null) {

                // QUESTION : Should we just return an empty list ? As if we don't have a max-width than we also can't generate smaller images.

                return Enumerable.Empty<VariationInfo>();

            } else {

                maxImageSize = Math.Min(Constants.MAX_IMAGE_WIDTH, metaData.Width);

            }

​

            var neededSizes = GetNeededVariantSizes( requestedMinWidth, requestedMaxWidth, maxImageSize );

            Console.WriteLine("max image size : " + maxImageSize);

            Console.WriteLine("min requested : " + requestedMinWidth);

            Console.WriteLine("max requested : " + requestedMaxWidth);

            Console.WriteLine(string.Join(", ", neededSizes.Select( size => size.ToString())));

            Console.WriteLine(string.Join(", ", neededSizes.Select( size => size.ToString())));

            Console.WriteLine("");

            // TODO this shouldn't lead to another list, but directly to the behavior of requesting or generating the images.

            // In the meantime it could also generate this list which is then returned to the user.

            return neededSizes.Select(size => 

                existingVariants.FirstOrDefault( variant => variant.Width == size && variant.MimeType == mime )

                    ?? new VariationInfo { Width = size, MimeType = mime }

            ).ToArray();

        }

        /// <summary>

        /// Gets the sizes for the variants needed to be returned.

        /// </summary>

        /// <param name="neededMin">The minimum needed variant size.</param>

        /// <param name="neededMax">The maximum neeeded variant size.</param>

        /// <param name="maxSize">The maximum size of the image.</param>

        /// <param name="allVariantSizes">The list of all variants which it can use. If null is the allVariantSizes will be generated.</param>

        public static IEnumerable<int> GetNeededVariantSizes( int neededMin, int neededMax, int maxSize = Constants.MAX_IMAGE_WIDTH, List<int> allVariantSizes = null )

        {

            if( allVariantSizes == null ) 

            {

                allVariantSizes = GenerateAllVariantSizes( maxSize )

                    .Reverse()

                    .ToList();

            }

            var allLength = allVariantSizes.Count();

            var closestMinIndex = allVariantSizes.ClosestLargerIndex( neededMin, allLength );

            var closestMaxIndex = allVariantSizes.ClosestLargerIndex( neededMax, allLength );

​

            var numNeeded = closestMaxIndex - closestMinIndex;

            var step = 1d;

​

            if( numNeeded > Constants.MAX_VARIANT_RETURNS )

            {

                step = Math.Max((double)step, numNeeded / ((double)Constants.MAX_VARIANT_RETURNS - 1));

            }

​

            var aproxIndex = (double)closestMinIndex;

            var index = (int)aproxIndex;

            do {

                var stepSize = allVariantSizes[index];

​

                yield return stepSize;

​

                aproxIndex += step;

                index = (int)aproxIndex;

            } while ( index <= closestMaxIndex);

        }

        /// <summary>

        /// Gets a descending list with all sizes from a certain maximum to (defaultly 0).

        /// </summary>

        /// <param name="fromMax">The maximum number from which to generate all sizes.</param>

        /// <param name="toMin">The minimum number to which the sizes should be generated.</param>

        public static IEnumerable<int> GenerateAllVariantSizes( int fromMax, int toMin = 0 ) {

            int size = fromMax;

            do {

                yield return size;

                size -= Constants.VARIATIONS_INCREMENT;

            } while( size > toMin );

        }

        /// <summary>

        /// Gets finds the index of the number in the list or an index of a larger number.

        /// </summary>

        /// <param name="ascOrderedList">An ascending ordered list of integers.</param>

        /// <param name="number">The number to find in the list.</param>

        /// <param name="listLength">The length of the list.</param>

        /// <remarks>

        /// ATTENTION : If your list is not ordered ascending then this function will give unexpected results.

        /// </remarks>

        public static int ClosestLargerIndex(this List<int> ascOrderedList, int number, int? listLength = null) {

            var index = ascOrderedList.BinarySearch(number);

            if( index < 0 ) 

            {

                index = ~index;

                index = Math.Min(index, ((listLength ?? ascOrderedList.Count()) - 1));

            }

            return index;

        }

    }

}