using KLHZ.Trader.Core.DataLayer.Entities.Prices;
using KLHZ.Trader.Core.Declisions.Utils;
using KLHZ.Trader.Core.Math.Declisions.Services;

namespace KLHZ.Trader.Core.Tests
{
    public class HistoryProcessingInstrumentsTests
    {
        private static PriceChange[] GetHistory(int count, string figi, DateTime startDt, float startValue, float step)
        {
            var res = new PriceChange[count];
            if (count != 0)
            {
                for (int i = 0; i < count; i++)
                {
                    startValue += step;
                    startDt = startDt.AddSeconds(1);
                    res[i] = new PriceChange()
                    {
                        Figi = figi,
                        Ticker = figi + "_ticker",
                        Id = i,
                        Time = startDt,
                        Value = (decimal)startValue,
                    };
                }
            }
            return res;
        }

        [Test]
        public void Test0()
        {
            var figi = "figi";
            var startDate = new DateTime(2020, 1, 1, 1, 0, 0, DateTimeKind.Utc);
            var count = 100;
            var step = 0;
            var startValue = 10;
            var unit = new PriceHistoryCacheUnit(figi, GetHistory(count, figi, startDate, startValue, step));

            var data = unit.GetData().Result;
            var endDate = startDate.AddSeconds(count);
            Assert.IsTrue(data.timestamps.Last() == endDate);
            Assert.IsTrue(data.prices.Last() == startValue + step * count);

            var periodLength = 4;
            var shift = 0;
            var result = HistoryProcessingInstruments.GetPriceDiffForTimeSpan(unit, TimeSpan.FromSeconds(shift), TimeSpan.FromSeconds(periodLength));

            var maxValue = startValue + (step > 0 ? (step * count) - step * shift : (step * count) - (step * (shift + periodLength)));
            var minValue = startValue + (step > 0 ? (step * count) - (step * (shift + periodLength)) : (step * count) - step * shift);
            var firstPrice = startValue + (step * count) - (step * (shift + periodLength));
            var lastPrice = startValue + (step * count) - step * shift;

            var diff = firstPrice - lastPrice;


            Assert.IsTrue(result.LastPrice == lastPrice);
            Assert.IsTrue(result.FirstPrice == firstPrice);
            Assert.IsTrue(result.PeriodMax == maxValue);
            Assert.IsTrue(result.PeriodMin == minValue);
            Assert.IsTrue(result.PeriodDiff == diff);
        }

        [Test]
        public void Test1()
        {
            var figi = "figi";
            var startDate = new DateTime(2020, 1, 1, 1, 0, 0, DateTimeKind.Utc);
            var count = 100;
            var step = 0.5f;
            var startValue = 10;
            var unit = new PriceHistoryCacheUnit(figi, GetHistory(count, figi, startDate, startValue, step));

            var data = unit.GetData().Result;
            var endDate = startDate.AddSeconds(count);
            Assert.IsTrue(data.timestamps.Last() == endDate);
            Assert.IsTrue(data.prices.Last() == startValue + step * count);

            var periodLength = 4;
            var shift = 0;
            var result = HistoryProcessingInstruments.GetPriceDiffForTimeSpan(unit, TimeSpan.FromSeconds(shift), TimeSpan.FromSeconds(periodLength));

            var maxValue = startValue + (step > 0 ? (step * count) - step * shift : (step * count) - (step * (shift + periodLength)));
            var minValue = startValue + (step > 0 ? (step * count) - (step * (shift + periodLength)) : (step * count) - step * shift);
            var firstPrice = startValue + (step * count) - (step * (shift + periodLength));
            var lastPrice = startValue + (step * count) - step * shift;

            var diff = lastPrice - firstPrice;


            Assert.IsTrue(result.LastPrice == lastPrice);
            Assert.IsTrue(result.FirstPrice == firstPrice);
            Assert.IsTrue(result.PeriodMax == maxValue);
            Assert.IsTrue(result.PeriodMin == minValue);
            Assert.IsTrue(result.PeriodDiff == diff);
        }

        [Test]
        public void Test2()
        {
            var figi = "figi";
            var startDate = new DateTime(2020, 1, 1, 1, 0, 0, DateTimeKind.Utc);
            var count = 100;
            var step = 0.5f;
            var startValue = 10;

            var unit = new PriceHistoryCacheUnit(figi, GetHistory(count, figi, startDate, startValue, step));

            var data = unit.GetData().Result;
            var endDate = startDate.AddSeconds(count);
            Assert.IsTrue(data.timestamps.Last() == endDate);
            Assert.IsTrue(data.prices.Last() == startValue + step * count);

            var periodLength = 4;
            var shift = 1;
            var result = HistoryProcessingInstruments.GetPriceDiffForTimeSpan(unit, TimeSpan.FromSeconds(shift), TimeSpan.FromSeconds(periodLength));

            var maxValue = startValue + (step > 0 ? (step * count) - step * shift : (step * count) - (step * (shift + periodLength)));
            var minValue = startValue + (step > 0 ? (step * count) - (step * (shift + periodLength)) : (step * count) - step * shift);
            var firstPrice = startValue + (step * count) - (step * (shift + periodLength));
            var lastPrice = startValue + (step * count) - step * shift;

            var diff = lastPrice - firstPrice;


            Assert.IsTrue(result.LastPrice == lastPrice);
            Assert.IsTrue(result.FirstPrice == firstPrice);
            Assert.IsTrue(result.PeriodMax == maxValue);
            Assert.IsTrue(result.PeriodMin == minValue);
            Assert.IsTrue(result.PeriodDiff == diff);
        }

        [Test]
        public void Test3()
        {
            var figi = "figi";
            var startDate = new DateTime(2020, 1, 1, 1, 0, 0, DateTimeKind.Utc);
            var count = 100;
            var step = -0.5f;
            var startValue = 10;

            var unit = new PriceHistoryCacheUnit(figi, GetHistory(count, figi, startDate, startValue, step));

            var data = unit.GetData().Result;
            var endDate = startDate.AddSeconds(count);
            Assert.IsTrue(data.timestamps.Last() == endDate);
            Assert.IsTrue(data.prices.Last() == startValue + step * count);

            var periodLength = 4;
            var shift = 0;
            var result = HistoryProcessingInstruments.GetPriceDiffForTimeSpan(unit, TimeSpan.FromSeconds(shift), TimeSpan.FromSeconds(periodLength));

            var maxValue = startValue + (step > 0 ? (step * count) - step * shift : (step * count) - (step * (shift + periodLength)));
            var minValue = startValue + (step > 0 ? (step * count) - (step * (shift + periodLength)) : (step * count) - step * shift);
            var firstPrice = startValue + (step * count) - (step * (shift + periodLength));
            var lastPrice = startValue + (step * count) - step * shift;

            var diff = lastPrice - firstPrice;


            Assert.IsTrue(result.LastPrice == lastPrice);
            Assert.IsTrue(result.FirstPrice == firstPrice);
            Assert.IsTrue(result.PeriodMax == maxValue);
            Assert.IsTrue(result.PeriodMin == minValue);
            Assert.IsTrue(result.PeriodDiff == diff);
        }

        [Test]
        public void Test4()
        {
            var figi = "figi";
            var startDate = new DateTime(2020, 1, 1, 1, 0, 0, DateTimeKind.Utc);
            var count = 100;
            var step = -0.5f;
            var startValue = 10;

            var unit = new PriceHistoryCacheUnit(figi, GetHistory(count, figi, startDate, startValue, step));

            var data = unit.GetData().Result;
            var endDate = startDate.AddSeconds(count);
            Assert.IsTrue(data.timestamps.Last() == endDate);
            Assert.IsTrue(data.prices.Last() == startValue + step * count);

            var periodLength = 4;
            var shift = 3;
            var result = HistoryProcessingInstruments.GetPriceDiffForTimeSpan(unit, TimeSpan.FromSeconds(shift), TimeSpan.FromSeconds(periodLength));

            var maxValue = startValue + (step > 0 ? (step * count) - step * shift : (step * count) - (step * (shift + periodLength)));
            var minValue = startValue + (step > 0 ? (step * count) - (step * (shift + periodLength)) : (step * count) - step * shift);
            var firstPrice = startValue + (step * count) - (step * (shift + periodLength));
            var lastPrice = startValue + (step * count) - step * shift;

            var diff = lastPrice - firstPrice;


            Assert.IsTrue(result.LastPrice == lastPrice);
            Assert.IsTrue(result.FirstPrice == firstPrice);
            Assert.IsTrue(result.PeriodMax == maxValue);
            Assert.IsTrue(result.PeriodMin == minValue);
            Assert.IsTrue(result.PeriodDiff == diff);
        }

        [Test]
        public void Test5()
        {
            var figi = "figi";
            var startDate = new DateTime(2020, 1, 1, 1, 0, 0, DateTimeKind.Utc);
            var count = 100;
            var step = -0.5f;
            var startValue = 10;

            var unit = new PriceHistoryCacheUnit(figi, GetHistory(count, figi, startDate, startValue, step));

            var data = unit.GetData().Result;
            var endDate = startDate.AddSeconds(count);
            Assert.IsTrue(data.timestamps.Last() == endDate);
            Assert.IsTrue(data.prices.Last() == startValue + step * count);

            var periodLength = 4;
            var shift = 3;
            var result = HistoryProcessingInstruments.GetPriceDiffForTimeSpan(unit, TimeSpan.FromSeconds(shift), TimeSpan.FromSeconds(periodLength));

            var maxValue1 = startValue + (step > 0 ? (step * count) - step * shift : (step * count) - (step * (shift + periodLength)));
            var minValue1 = startValue + (step > 0 ? (step * count) - (step * (shift + periodLength)) : (step * count) - step * shift);
            var firstPrice1 = startValue + (step * count) - (step * (shift + periodLength));
            var lastPrice1 = startValue + (step * count) - step * shift;

            var diff1 = lastPrice1 - firstPrice1;


            Assert.IsTrue(result.LastPrice == lastPrice1);
            Assert.IsTrue(result.FirstPrice == firstPrice1);
            Assert.IsTrue(result.PeriodMax == maxValue1);
            Assert.IsTrue(result.PeriodMin == minValue1);
            Assert.IsTrue(result.PeriodDiff == diff1);



            var unit2 = new PriceHistoryCacheUnit(figi);
            var data2 = unit.GetData().Result;
            for (int i = 0; i < data2.prices.Length; i++)
            {
                var value = (decimal)data2.prices[i];
                if (i == data2.prices.Length - 5)
                {
                    value = 100;
                }
                else if (i == data2.prices.Length - 6)
                {
                    value = -100;
                }
                unit2.AddData(new PriceChange()
                {
                    Figi = figi,
                    Ticker = figi,
                    Time = data2.timestamps[i],
                    Value = value
                });

            }

            var result2 = HistoryProcessingInstruments.GetPriceDiffForTimeSpan(unit2, TimeSpan.FromSeconds(shift), TimeSpan.FromSeconds(periodLength));

            var maxValue2 = 100;
            var minValue2 = -100;

            Assert.IsTrue(result2.LastPrice == result.LastPrice);
            Assert.IsTrue(result2.FirstPrice == result.FirstPrice);
            Assert.IsTrue(result2.PeriodMax == maxValue2);
            Assert.IsTrue(result2.PeriodMin == minValue2);
            Assert.IsTrue(result2.PeriodDiff == result.PeriodDiff);
        }
    }
}