using System;
using System.Collections.Generic;
using System.Linq;

using CodeJam.Arithmetic;
using CodeJam.Collections;
using CodeJam.PerfTests;

using JetBrains.Annotations;

using NUnit.Framework;

using static CodeJam.AssemblyWideConfig;
using static CodeJam.PerfTests.CompetitionHelpers;

// ReSharper disable once CheckNamespace

namespace CodeJam
{
    [PublicAPI]
    [TestFixture(Category = PerfTestCategory + ": EnumHelper")]
    public class TempPerfTests
    {
        public class Data
        {
            public Data(int structField)
            {
                StructField = structField;
                StringField = structField.ToString();
            }

            public int StructField { get; }
            public string StringField { get; }
        }

        private static readonly Data[] _data = Enumerable
            .Range(1, 1000)
            .Select(i => new Data(i))
            .ToArray();

        private static T MyMinBy<T, TValue>(IEnumerable<T> source, Func<T, TValue> selector)
        {
            var greater = Operators<TValue>.GreaterThan;
            T result = default(T);
            TValue resultValue = default(TValue);
            bool hasData = false;
            foreach (var item in source)
            {
                if (!hasData || greater(resultValue, selector(item)))
                {
                    result = item;
                    resultValue = selector(item);
                    hasData = true;
                }
            }
            if (!hasData)
                throw new Exception("Bla-bla-bla");
            return result;
        }

        private static T MyMinByComparer<T, TValue>(IEnumerable<T> source, Func<T, TValue> selector)
        {
            var comparer = Comparer<TValue>.Default;
            T result = default(T);
            TValue resultValue = default(TValue);
            bool hasData = false;
            foreach (var item in source)
            {
                if (!hasData || comparer.Compare(resultValue, selector(item)) > 0)
                {
                    result = item;
                    resultValue = selector(item);
                    hasData = true;
                }
            }
            if (!hasData)
                throw new Exception("Bla-bla-bla");
            return result;
        }

        [Test]
        public void RunMinByIntCase() => Competition.Run<MinByIntCase>(RunConfig);

        public class MinByIntCase
        {
            [CompetitionBaseline]
            public Data MinCodeJam() => _data.MinBy(x => x.StructField);

            [CompetitionBenchmark(6.98, 15.66)]
            public Data MinNaive() => _data.OrderBy(x => x.StructField).FirstOrDefault();

            [CompetitionBenchmark(0.81, 1.67)]
            public Data MinOk() => MyMinBy(_data, x => x.StructField);

            [CompetitionBenchmark(0.83, 1.64)]
            public Data MinOkComparer() => MyMinByComparer(_data, x => x.StructField);

            [CompetitionBenchmark(0.07, 0.18)]
            public Data MinDoneRight()
            {
                Data result = null;
                int resultValue = 0;
                var local = _data;
                foreach (var other in local)
                {
                    if (result == null || resultValue > other.StructField)
                    {
                        result = other;
                        resultValue = other.StructField;
                    }
                }
                return result;
            }
        }

        [Test]
        public void RunMinByStringCase() => Competition.Run<MinByStringCase>(RunConfig);

        public class MinByStringCase
        {
            [CompetitionBaseline]
            public Data MinCodeJam() => _data.MinBy(x => x.StringField);

            [CompetitionBenchmark(8.46, 21.14)]
            public Data MinNaive() => _data.OrderBy(x => x.StringField).FirstOrDefault();

            [CompetitionBenchmark(0.05, 0.11)]
            public Data MinOk() => MyMinBy(_data, x => x.StringField);

            [CompetitionBenchmark(0.53, 1.33)]
            public Data MinOkComparer() => MyMinByComparer(_data, x => x.StringField);

            [CompetitionBenchmark(0.53, 0.86)]
            public Data MinDoneRight()
            {
                Data result = null;
                string resultValue = null;
                var local = _data;
                foreach (var other in local)
                {
                    if (result == null || string.Compare(resultValue, other.StringField) > 0)
                    {
                        result = other;
                        resultValue = other.StringField;
                    }
                }
                return result;
            }
        }
    }
}