/*
 * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
 * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/

using System;
using System.Linq;
using NUnit.Framework;

namespace QuantConnect.Tests.Common
{
    [TestFixture]
    public class SeriesSamplerTests
    {
        private readonly DateTime _reference = new(2023, 2, 2);

        [TestCase(0, true)]
        [TestCase(1, true)]
        [TestCase(2, true)]
        [TestCase(3, true)]
        [TestCase(0, false)]
        [TestCase(1, false)]
        [TestCase(2, false)]
        [TestCase(3, false)]
        public void ReturnsIdentityFutureOrPastCandlestick(int dataPoints, bool futureOrPast)
        {
            var series = new CandlestickSeries { Name = "name" };
            for (var i = 0; i < dataPoints; i++)
            {
                series.AddPoint(new Candlestick(_reference.AddDays(futureOrPast ? (i + 1000) : i), 1, 1, 1, 1));
            }

            var sampler = new SeriesSampler(TimeSpan.FromDays(1));
            var sampled = sampler.Sample(series, _reference.AddDays(10), _reference.AddDays(11));

            // empty
            Assert.AreEqual(0, sampled.Values.Count);
        }

        [TestCase(0, true)]
        [TestCase(1, true)]
        [TestCase(2, true)]
        [TestCase(3, true)]
        [TestCase(0, false)]
        [TestCase(1, false)]
        [TestCase(2, false)]
        [TestCase(3, false)]
        public void ReturnsIdentityFutureOrPastPoints(int dataPoints, bool futureOrPast)
        {
            var series = new Series { Name = "name" };
            for (var i = 0; i < dataPoints; i++)
            {
                series.AddPoint(new ChartPoint(_reference.AddDays(futureOrPast ? (i + 1000) : i), 1));
            }

            var sampler = new SeriesSampler(TimeSpan.FromDays(1));
            var sampled = sampler.Sample(series, _reference.AddDays(10), _reference.AddDays(11));

            // empty
            Assert.AreEqual(0, sampled.Values.Count);
        }

        [TestCase(false)]
        [TestCase(true)]
        public void ReturnsIdentityOnSinglePoint(bool isNullValue)
        {
            var series = new Series {Name = "name"};
            series.AddPoint(new ChartPoint(_reference, isNullValue ? null: 1));

            var sampler = new SeriesSampler(TimeSpan.FromDays(1));

            var sampled = sampler.Sample(series, _reference.AddSeconds(-1), _reference.AddSeconds(1));

            var seriesValues = series.Values.Cast<ChartPoint>().ToList();
            var sampledValues = sampled.Values.Cast<ChartPoint>().ToList();

            Assert.AreEqual(1, sampled.Values.Count);
            Assert.AreEqual(seriesValues[0].x, sampledValues[0].x);
            Assert.AreEqual(seriesValues[0].y, sampledValues[0].y);
        }

        [TestCase(true)]
        [TestCase(false)]
        public void DownSamplesNullFirstValue(bool subSample)
        {
            var series = new Series { Name = "name" };
            series.AddPoint(new ChartPoint(_reference, null));
            series.AddPoint(_reference.AddDays(1), 2m);
            series.AddPoint(_reference.AddDays(2), 3m);
            series.AddPoint(_reference.AddDays(3), 4m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(1.5)) { SubSample = subSample };

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(3));

            var seriesValues = series.Values.Cast<ChartPoint>().ToList();
            var sampledValues = sampled.Values.Cast<ChartPoint>().ToList();

            Assert.AreEqual(3, sampled.Values.Count);

            Assert.AreEqual(seriesValues[0].x, sampledValues[0].x);
            Assert.AreEqual(seriesValues[1].y, sampledValues[0].y);

            Assert.AreEqual((seriesValues[1].x + seriesValues[2].x) / 2, sampledValues[1].x);
            Assert.AreEqual((seriesValues[1].y + seriesValues[2].y) / 2, sampledValues[1].y);

            Assert.AreEqual(seriesValues[3].x, sampledValues[2].x);
            Assert.AreEqual(seriesValues[3].y, sampledValues[2].y);
        }

        [TestCase(true)]
        [TestCase(false)]
        public void DownSamples(bool subSample)
        {
            var series = new Series {Name = "name"};
            series.AddPoint(_reference, 1m);
            series.AddPoint(_reference.AddDays(1), 2m);
            series.AddPoint(_reference.AddDays(2), 3m);
            series.AddPoint(_reference.AddDays(3), 4m);
            series.AddPoint(new ChartPoint(_reference.AddDays(4), null));
            series.AddPoint(_reference.AddDays(5), 5m);
            series.AddPoint(_reference.AddDays(6), 6m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(1.5)) { SubSample = subSample };

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(6));

            var seriesValues = series.Values.Cast<ChartPoint>().ToList();
            var sampledValues = sampled.Values.Cast<ChartPoint>().ToList();

            Assert.AreEqual(5, sampled.Values.Count);

            Assert.AreEqual(seriesValues[0].x, sampledValues[0].x);
            Assert.AreEqual(seriesValues[0].y, sampledValues[0].y);

            Assert.AreEqual((seriesValues[1].x + seriesValues[2].x)/2, sampledValues[1].x);
            Assert.AreEqual((seriesValues[1].y + seriesValues[2].y)/2, sampledValues[1].y);

            Assert.AreEqual(seriesValues[3].x, sampledValues[2].x);
            Assert.AreEqual(seriesValues[3].y, sampledValues[2].y);

            Assert.AreEqual((seriesValues[4].x + seriesValues[5].x) / 2, sampledValues[3].x);
            Assert.AreEqual(seriesValues[5].y, sampledValues[3].y);

            Assert.AreEqual(seriesValues[6].x, sampledValues[4].x);
            Assert.AreEqual(seriesValues[6].y, sampledValues[4].y);
        }

        [TestCase(true)]
        [TestCase(false)]
        public void DownSamplesWithTimeJump(bool subSample)
        {
            var series = new Series { Name = "name" };
            series.AddPoint(_reference, 1m);
            series.AddPoint(_reference.AddDays(1), 2m);
            series.AddPoint(_reference.AddDays(2), 3m);
            series.AddPoint(_reference.AddDays(3), 4m);
            series.AddPoint(new ChartPoint(_reference.AddDays(4), null));
            // time jump
            series.AddPoint(_reference.AddDays(20), 5m);
            series.AddPoint(_reference.AddDays(21), 6m);

            var span = TimeSpan.FromDays(1.5);
            var sampler = new SeriesSampler(span) { SubSample = subSample };

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(24));

            var seriesValues = series.Values.Cast<ChartPoint>().ToList();
            var sampledValues = sampled.Values.Cast<ChartPoint>().ToList();

            Assert.AreEqual(subSample ? 15 : 5, sampled.Values.Count);

            Assert.AreEqual(seriesValues[0].x, sampledValues[0].x);
            Assert.AreEqual(seriesValues[0].y, sampledValues[0].y);

            Assert.AreEqual((seriesValues[1].x + seriesValues[2].x) / 2, sampledValues[1].x);
            Assert.AreEqual((seriesValues[1].y + seriesValues[2].y) / 2, sampledValues[1].y);

            Assert.AreEqual(seriesValues[3].x, sampledValues[2].x);
            Assert.AreEqual(seriesValues[3].y, sampledValues[2].y);

            var expectedTime = seriesValues[3].x;
            for (var i = 3; i < 13; i++)
            {
                expectedTime += (long)span.TotalSeconds;

                if (subSample)
                {
                    Assert.AreEqual(expectedTime, sampledValues[i].x);
                    // all nulls
                    Assert.AreEqual(null, sampledValues[i].y);
                }
            }

            var expectedIndex = subSample ? 13 : 3;

            Assert.AreEqual(expectedTime + (long)span.TotalSeconds, sampledValues[expectedIndex].x);
            Assert.AreEqual(seriesValues[5].y, sampledValues[expectedIndex].y);

            expectedIndex++;
            Assert.AreEqual(seriesValues[6].x, sampledValues[expectedIndex].x);
            Assert.AreEqual(seriesValues[6].y, sampledValues[expectedIndex].y);
        }

        [Test]
        public void SubSamples()
        {
            var series = new Series {Name = "name"};
            series.AddPoint(_reference, 1m);
            series.AddPoint(_reference.AddDays(1), 2m);
            series.AddPoint(new ChartPoint(_reference.AddDays(2), null));
            series.AddPoint(_reference.AddDays(3), 4m);
            series.AddPoint(_reference.AddDays(4), 5m);
            series.AddPoint(_reference.AddDays(5), 6m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(0.5));

            var sampled = sampler.Sample(series, _reference.AddDays(1), _reference.AddDays(3));

            var seriesValues = series.Values.Cast<ChartPoint>().ToList();
            var sampledValues = sampled.Values.Cast<ChartPoint>().ToList();

            Assert.AreEqual(5, sampled.Values.Count);

            Assert.AreEqual(seriesValues[1].x, sampledValues[0].x);
            Assert.AreEqual(seriesValues[1].y, sampledValues[0].y);

            Assert.AreEqual((seriesValues[1].x + seriesValues[2].x) / 2, sampledValues[1].x);
            Assert.AreEqual(seriesValues[1].y, sampledValues[1].y);
            Assert.AreEqual(seriesValues[2].x, sampledValues[2].x);
            Assert.AreEqual(null, sampledValues[2].y);

            Assert.AreEqual((seriesValues[3].x + seriesValues[2].x) / 2, sampledValues[3].x);
            Assert.AreEqual(seriesValues[3].y, sampledValues[3].y);
            Assert.AreEqual(seriesValues[3].x, sampledValues[4].x);
            Assert.AreEqual(seriesValues[3].y, sampledValues[4].y);
        }

        [Test]
        public void SubSamplesDisabled()
        {
            var series = new Series { Name = "name" };
            series.AddPoint(_reference, 1m);
            series.AddPoint(_reference.AddDays(1), 2m);
            series.AddPoint(new ChartPoint(_reference.AddDays(2), null));
            // even if the data doesn't fit exactly the expected bar span we expect it to pass through
            series.AddPoint(_reference.AddDays(2.8), 4m);
            series.AddPoint(_reference.AddDays(4), 5m);
            series.AddPoint(_reference.AddDays(5), 6m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(0.5)) { SubSample = false };

            var sampled = sampler.Sample(series, _reference.AddDays(1), _reference.AddDays(3));

            var seriesValues = series.Values.Cast<ChartPoint>().ToList();
            var sampledValues = sampled.Values.Cast<ChartPoint>().ToList();

            Assert.AreEqual(3, sampled.Values.Count);

            Assert.AreEqual(seriesValues[1].x, sampledValues[0].x);
            Assert.AreEqual(seriesValues[1].y, sampledValues[0].y);

            Assert.AreEqual(seriesValues[2].x, sampledValues[1].x);
            Assert.AreEqual(seriesValues[2].y, sampledValues[1].y);

            Assert.AreEqual(seriesValues[3].x, sampledValues[2].x);
            Assert.AreEqual(seriesValues[3].y, sampledValues[2].y);
        }

        [Test]
        public void SubSamplesWithTimeJump()
        {
            var series = new Series { Name = "name" };
            series.AddPoint(_reference, 1m);
            series.AddPoint(_reference.AddDays(1), 2m);
            series.AddPoint(new ChartPoint(_reference.AddDays(2), null));
            series.AddPoint(_reference.AddDays(10), 4m);
            series.AddPoint(_reference.AddDays(11), 5m);
            series.AddPoint(_reference.AddDays(12), 6m);

            var span = TimeSpan.FromDays(0.5);
            var sampler = new SeriesSampler(span);

            var sampled = sampler.Sample(series, _reference.AddDays(1), _reference.AddDays(12));

            var seriesValues = series.Values.Cast<ChartPoint>().ToList();
            var sampledValues = sampled.Values.Cast<ChartPoint>().ToList();

            Assert.AreEqual(23, sampled.Values.Count);

            Assert.AreEqual(seriesValues[1].x, sampledValues[0].x);
            Assert.AreEqual(seriesValues[1].y, sampledValues[0].y);

            var expectedTime = seriesValues[1].x;
            expectedTime += (long)span.TotalSeconds;

            Assert.AreEqual(expectedTime, sampledValues[1].x);
            Assert.AreEqual(seriesValues[1].y, sampledValues[1].y);

            for (var i = 2; i < 17; i++)
            {
                expectedTime += (long)span.TotalSeconds;

                Assert.AreEqual(expectedTime, sampledValues[i].x);
                Assert.AreEqual(null, sampledValues[i].y);
            }

            Assert.AreEqual(seriesValues[4].x, sampledValues[20].x);
            Assert.AreEqual(seriesValues[4].y, sampledValues[20].y);

            Assert.AreEqual(seriesValues[4].x + (long)span.TotalSeconds, sampledValues[21].x);
            Assert.AreEqual((seriesValues[4].y + seriesValues[5].y) / 2, sampledValues[21].y);

            Assert.AreEqual(seriesValues[5].x, sampledValues[22].x);
            Assert.AreEqual(seriesValues[5].y, sampledValues[22].y);
        }

        [Test]
        public void DoesNotSampleBeforeStart()
        {
            var series = new Series { Name = "name" };
            series.AddPoint(_reference, 1m);
            series.AddPoint(_reference.AddDays(1), 2m);
            series.AddPoint(_reference.AddDays(2), 3m);
            series.AddPoint(_reference.AddDays(3), 4m);
            series.AddPoint(_reference.AddDays(4), 5m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(1));

            var sampled = sampler.Sample(series, _reference.AddDays(-1), _reference.AddDays(2));

            var seriesValues = series.Values.Cast<ChartPoint>().ToList();
            var sampledValues = sampled.Values.Cast<ChartPoint>().ToList();

            Assert.AreEqual(3, sampled.Values.Count);

            Assert.AreEqual(seriesValues[0].x, sampledValues[0].x);
            Assert.AreEqual(seriesValues[0].y, sampledValues[0].y);

            Assert.AreEqual(seriesValues[1].x, sampledValues[1].x);
            Assert.AreEqual(seriesValues[1].y, sampledValues[1].y);

            Assert.AreEqual(seriesValues[2].x, sampledValues[2].x);
            Assert.AreEqual(seriesValues[2].y, sampledValues[2].y);
        }

        [Test]
        public void HandlesDuplicateTimes()
        {
            var series = new Series();
            series.Values.Add(new ChartPoint(_reference, 1m));
            series.Values.Add(new ChartPoint(_reference, 2m));
            series.Values.Add(new ChartPoint(_reference.AddDays(1), 3m));

            var sampler = new SeriesSampler(TimeSpan.FromDays(1));
            var sampled = sampler.Sample(series, _reference, _reference.AddDays(1));

            // sampler will only produce one value at the time
            // it was also respect the latest value

            Assert.AreEqual(2, sampled.Values.Count);
            foreach (var pair in series.Values.Skip(1).Cast<ChartPoint>().Zip(sampled.Values.Cast<ChartPoint>(), Tuple.Create))
            {
                Assert.AreEqual(pair.Item1.x, pair.Item2.x);
                Assert.AreEqual(pair.Item1.y, pair.Item2.y);
            }
        }

        [Test]
        public void DoesNotSampleScatterPlots()
        {
            var scatter = new Series("scatter", SeriesType.Scatter, 0, "$");
            scatter.AddPoint(_reference, 1m);
            scatter.AddPoint(_reference, 3m);
            scatter.AddPoint(_reference.AddSeconds(1), 1.5m);
            scatter.AddPoint(_reference.AddSeconds(0.5), 1.5m);

            var sampler = new SeriesSampler(TimeSpan.FromMilliseconds(1));
            var sampled = sampler.Sample(scatter, _reference, _reference.AddDays(1));
            foreach (var pair in scatter.Values.Cast<ChartPoint>().Zip(sampled.Values.Cast<ChartPoint>(), Tuple.Create))
            {
                Assert.AreEqual(pair.Item1.x, pair.Item2.x);
                Assert.AreEqual(pair.Item1.y, pair.Item2.y);
            }
        }

        [Test]
        public void SubSampleTreemapPlots()
        {
            var treeMap = new Series("Treemap", SeriesType.Treemap, 0, "$");
            treeMap.AddPoint(_reference, 1m);
            treeMap.AddPoint(_reference.AddSeconds(0.5), 1.5m);
            treeMap.AddPoint(_reference.AddMinutes(1), 2m);

            var sampler = new SeriesSampler(TimeSpan.FromMilliseconds(1));
            var sampled = sampler.Sample(treeMap, _reference, _reference.AddDays(1));

            Assert.AreEqual(1000 * 60 + 1, sampled.Values.Count);
            foreach (var newValues in sampled.Values.Cast<ChartPoint>())
            {
                var expected = (ChartPoint)treeMap.Values[0];
                if (newValues.Time >= treeMap.Values[1].Time)
                {
                    expected = (ChartPoint)treeMap.Values[1];
                }
                if (newValues.Time >= treeMap.Values[2].Time)
                {
                    expected = (ChartPoint)treeMap.Values[2];
                }
                Assert.AreEqual(expected.y, newValues.y);
            }
        }

        [Test]
        public void DownSampleTreemapPlots()
        {
            var treeMap = new Series("Treemap", SeriesType.Treemap, 0, "$");
            treeMap.AddPoint(_reference, 1m);
            treeMap.AddPoint(_reference, 3m);
            treeMap.AddPoint(_reference.AddSeconds(0.5), 1.5m);
            treeMap.AddPoint(_reference.AddSeconds(1), 1.5m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(1));
            var sampled = sampler.Sample(treeMap, _reference, _reference.AddDays(1));

            // the last value
            Assert.AreEqual(1, sampled.Values.Count);
            Assert.AreEqual(_reference, sampled.Values[0].Time);
            Assert.AreEqual(((ChartPoint)treeMap.Values.Last()).Y, ((ChartPoint)sampled.Values[0]).Y);
        }

        [Test]
        public void EmitsEmptySeriesWithSinglePointOutsideOfStartStop()
        {
            var series = new Series { Name = "name" };
            series.AddPoint(_reference.AddSeconds(-1), 1m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(1));

            var sampled = sampler.Sample(series, _reference, _reference);
            Assert.AreEqual(0, sampled.Values.Count);
        }

        [Test]
        public void ReturnsIdentityOnSinglePointCandlestickSeries()
        {
            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(1));

            var sampled = sampler.Sample(series, _reference.AddSeconds(-1), _reference.AddSeconds(1));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(1, sampledValues.Count);
            Assert.AreEqual(seriesValues[0].Time, sampledValues[0].Time);
            Assert.AreEqual(seriesValues[0].Open, sampledValues[0].Open);
            Assert.AreEqual(seriesValues[0].High, sampledValues[0].High);
            Assert.AreEqual(seriesValues[0].Low, sampledValues[0].Low);
            Assert.AreEqual(seriesValues[0].Close, sampledValues[0].Close);
        }

        [TestCase(true)]
        [TestCase(false)]
        public void DoesNotSampleCandlestickSeriesBeforeStart(bool subSample)
        {
            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(2), 4m, 4m, 3m, 3m);
            series.AddPoint(_reference.AddDays(3), 2m, 2m, 1m, 1m);
            series.AddPoint(_reference.AddDays(4), 2m, 3m, 2m, 3m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(1)) { SubSample = subSample };

            var sampled = sampler.Sample(series, _reference.AddDays(-1), _reference.AddDays(2));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(3, sampled.Values.Count);

            for (var i = 0; i < sampledValues.Count; i++)
            {
                Assert.AreEqual(seriesValues[i].Time, sampledValues[i].Time);
                AssertCandlesticksValuesAreEqual(seriesValues[i], sampledValues[i]);
            }
        }

        [TestCase(true)]
        [TestCase(false)]
        public void DownSamplesCandlestickSeriesWithStopSameAsLastPoint(bool subSample)
        {
            // Original series is sampled at 1 day intervals
            // Sampled series is sampled at 1.5 day intervals
            //      Original series: |---------|---------|---------|
            //      Sampled series:  |--------------|--------------|

            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(2), 4m, 4m, 3m, 3m);
            series.AddPoint(_reference.AddDays(3), 2m, 2m, 1m, 1m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(1.5)) { SubSample = subSample };

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(3));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(3, sampled.Values.Count);

            Assert.AreEqual(seriesValues[0].Time, sampledValues[0].Time);
            AssertCandlesticksValuesAreEqual(seriesValues[0], sampledValues[0]);

            Assert.AreEqual(seriesValues[0].Time.AddDays(1.5), sampledValues[1].Time);
            Assert.AreEqual(seriesValues[1].Open, sampledValues[1].Open);
            Assert.AreEqual(Math.Max(seriesValues[1].High.Value, seriesValues[2].High.Value), sampledValues[1].High);
            Assert.AreEqual(Math.Min(seriesValues[1].Low.Value, seriesValues[2].Low.Value), sampledValues[1].Low);
            Assert.AreEqual(InterpolateClose(seriesValues[1], seriesValues[2], TimeSpan.FromDays(1), sampledValues[1].LongTime), sampledValues[1].Close);

            Assert.AreEqual(seriesValues[0].Time.AddDays(2 * 1.5), sampledValues[2].Time);
            Assert.AreEqual(seriesValues[3].Open, sampledValues[2].Open);
            Assert.AreEqual(seriesValues[3].High, sampledValues[2].High);
            Assert.AreEqual(seriesValues[3].Low, sampledValues[2].Low);
            Assert.AreEqual(seriesValues[3].Close, sampledValues[2].Close);
        }

        [TestCase(true)]
        [TestCase(false)]
        public void DownSamplesCandlestickSeriesWithStopAfterLastPoint(bool subSample)
        {
            // Original series is sampled at 1 day intervals
            // Sampled series is sampled at 1.5 day intervals
            //      Original series: |---------|---------|---------|---------|
            //      Sampled series:  |--------------|--------------|--------------

            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(2), 4m, 4m, 3m, 3m);
            series.AddPoint(_reference.AddDays(3), 2m, 2m, 1m, 1m);
            series.AddPoint(_reference.AddDays(4), 2m, 3m, 2m, 3m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(1.5)) { SubSample = subSample };

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(4));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(3, sampled.Values.Count);

            Assert.AreEqual(seriesValues[0].Time, sampledValues[0].Time);
            AssertCandlesticksValuesAreEqual(seriesValues[0], sampledValues[0]);

            Assert.AreEqual(seriesValues[0].Time.AddDays(1.5), sampledValues[1].Time);
            Assert.AreEqual(seriesValues[1].Open, sampledValues[1].Open);
            Assert.AreEqual(Math.Max(seriesValues[1].High.Value, seriesValues[2].High.Value), sampledValues[1].High);
            Assert.AreEqual(Math.Min(seriesValues[1].Low.Value, seriesValues[2].Low.Value), sampledValues[1].Low);
            Assert.AreEqual(InterpolateClose(seriesValues[1], seriesValues[2], TimeSpan.FromDays(1), sampledValues[1].LongTime), sampledValues[1].Close);

            Assert.AreEqual(seriesValues[0].Time.AddDays(2 * 1.5), sampledValues[2].Time);
            Assert.AreEqual(seriesValues[3].Open, sampledValues[2].Open);
            Assert.AreEqual(seriesValues[3].High, sampledValues[2].High);
            Assert.AreEqual(seriesValues[3].Low, sampledValues[2].Low);
            Assert.AreEqual(seriesValues[3].Close, sampledValues[2].Close);
        }

        [TestCase(true)]
        [TestCase(false)]
        public void DownSamplesCandlestickSeriesWithResamplePeriodSpanningMultipleCandlesticks(bool subSample)
        {
            // Original series is sampled at 1 day intervals
            // Sampled series is sampled at 2.5 day intervals
            //      Original series: |---------|---------|---------|---------|---------|---------|---------|
            //      Sampled series:  |------------------------|------------------------|-----------------------

            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(2), 4m, 4m, 3m, 3m);
            series.AddPoint(_reference.AddDays(3), 2m, 2m, 1m, 1m);
            series.AddPoint(_reference.AddDays(4), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(5), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(6), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(7), 2m, 3m, 2m, 3m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(2.5)) { SubSample = subSample };

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(5));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(3, sampled.Values.Count);

            Assert.AreEqual(seriesValues[0].Time, sampledValues[0].Time);
            AssertCandlesticksValuesAreEqual(seriesValues[0], sampledValues[0]);

            Assert.AreEqual(seriesValues[0].Time.AddDays(2.5), sampledValues[1].Time);
            Assert.AreEqual(seriesValues[1].Open, sampledValues[1].Open);
            Assert.AreEqual(new[] { seriesValues[1].High, seriesValues[2].High, seriesValues[3].High }.Max(), sampledValues[1].High);
            Assert.AreEqual(new[] { seriesValues[1].Low, seriesValues[2].Low, seriesValues[3].Low }.Min(), sampledValues[1].Low);
            Assert.AreEqual((double)InterpolateClose(seriesValues[1], seriesValues[3], TimeSpan.FromDays(1), sampledValues[1].LongTime), (double)sampledValues[1].Close, delta: 1e-3);

            Assert.AreEqual(seriesValues[0].Time.AddDays(2 * 2.5), sampledValues[2].Time);
            Assert.AreEqual(seriesValues[4].Open, sampledValues[2].Open);
            Assert.AreEqual(Math.Max(seriesValues[4].High.Value, seriesValues[5].High.Value), sampledValues[2].High);
            Assert.AreEqual(Math.Min(seriesValues[4].Low.Value, seriesValues[5].Low.Value), sampledValues[2].Low);
            Assert.AreEqual(seriesValues[5].Close, sampledValues[2].Close);
        }

        private static decimal InterpolateClose(Candlestick prev, Candlestick next, TimeSpan candleSpan, long time)
        {
            var prevOpenUnitTime = Time.DateTimeToUnixTimeStamp(prev.Time - candleSpan).SafeDecimalCast();
            return (next.Close.Value - prev.Open.Value) * (time - prevOpenUnitTime) / (next.LongTime - prevOpenUnitTime) + prev.Open.Value;
        }

        [TestCase(true)]
        [TestCase(false)]
        public void DownSamplesCandlestickSeriesWithStopBeforeLastPoint(bool subSample)
        {
            // Original series is sampled at 1 day intervals
            // Sampled series is sampled at 1.25 day intervals
            //      Original series: |-----------|-----------|-----------|-----------|
            //      Sampled series:  |--------------|--------------|--------------|

            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(2), 4m, 4m, 3m, 3m);
            series.AddPoint(_reference.AddDays(3), 2m, 2m, 1m, 1m);
            series.AddPoint(_reference.AddDays(4), 2m, 3m, 2m, 3m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(1.25)) { SubSample = subSample };

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(4));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(4, sampled.Values.Count);

            Assert.AreEqual(seriesValues[0].Time, sampledValues[0].Time);
            AssertCandlesticksValuesAreEqual(seriesValues[0], sampledValues[0]);

            Assert.AreEqual(seriesValues[0].Time.AddDays(1.25), sampledValues[1].Time);
            Assert.AreEqual(seriesValues[1].Open, sampledValues[1].Open);
            Assert.AreEqual(Math.Max(seriesValues[1].High.Value, seriesValues[2].High.Value), sampledValues[1].High);
            Assert.AreEqual(Math.Min(seriesValues[1].Low.Value, seriesValues[2].Low.Value), sampledValues[1].Low);
            Assert.AreEqual(InterpolateClose(seriesValues[1], seriesValues[2], TimeSpan.FromDays(1), sampledValues[1].LongTime), sampledValues[1].Close);

            Assert.AreEqual(seriesValues[0].Time.AddDays(2 * 1.25), sampledValues[2].Time);
            Assert.AreEqual(seriesValues[3].Open, sampledValues[2].Open);
            Assert.AreEqual(seriesValues[3].High, sampledValues[2].High);
            Assert.AreEqual(1.5m, sampledValues[2].Low);
            Assert.AreEqual(InterpolateClose(seriesValues[3], seriesValues[3], TimeSpan.FromDays(1), sampledValues[2].LongTime), sampledValues[2].Close);

            Assert.AreEqual(seriesValues[0].Time.AddDays(3 * 1.25), sampledValues[3].Time);
            Assert.AreEqual(seriesValues[4].Open, sampledValues[3].Open);
            Assert.AreEqual(2.75m, sampledValues[3].High);
            Assert.AreEqual(seriesValues[4].Low, sampledValues[3].Low);
            Assert.AreEqual(InterpolateClose(seriesValues[4], seriesValues[4], TimeSpan.FromDays(1), sampledValues[3].LongTime), sampledValues[3].Close);
        }

        [Test]
        public void SubSamplesCandlestickSeries()
        {
            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(2), 4m, 4m, 3m, 3m);
            series.AddPoint(_reference.AddDays(3), 2m, 2m, 1m, 1m);
            series.AddPoint(_reference.AddDays(4), 2m, 3m, 2m, 3m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(1));

            var sampled = sampler.Sample(series, _reference.AddDays(1), _reference.AddDays(2));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(2, sampled.Values.Count);

            for (var i = 0; i < sampledValues.Count; i++)
            {
                Assert.AreEqual(seriesValues[i + 1].Time, sampledValues[i].Time);
                AssertCandlesticksValuesAreEqual(seriesValues[i + 1], sampledValues[i]);
            }
        }

        [Test]
        public void SamplesCandlestickSeriesWithHigherSamplingResolution()
        {
            // Original series is sampled at 1 day intervals
            // Sampled series is sampled at 0.25 day intervals
            //      Original series: |-------------------|-------------------|
            //      Sampled series:  |----|----|----|----|----|----|----|----|

            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(2), 4m, 4m, 3m, 3m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(0.25));

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(2));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(9, sampled.Values.Count);

            // First half:

            Assert.AreEqual(seriesValues[0].Time, sampledValues[0].Time);
            AssertCandlesticksValuesAreEqual(seriesValues[0], sampledValues[0]);

            Assert.AreEqual(seriesValues[0].Time.AddDays(0.25), sampledValues[1].Time);
            Assert.AreEqual(seriesValues[1].Open, sampledValues[1].Open);
            Assert.AreEqual(2.25, sampledValues[1].High);
            Assert.AreEqual(seriesValues[1].Low, sampledValues[1].Low);
            Assert.AreEqual(InterpolateClose(seriesValues[1], seriesValues[1], TimeSpan.FromDays(1), sampledValues[1].LongTime), sampledValues[1].Close);

            Assert.AreEqual(seriesValues[0].Time.AddDays(2 * 0.25), sampledValues[2].Time);
            Assert.AreEqual(sampledValues[1].Close, sampledValues[2].Open);
            Assert.AreEqual(2.5, sampledValues[2].High);
            Assert.AreEqual(2.25, sampledValues[2].Low);
            Assert.AreEqual(InterpolateClose(seriesValues[1], seriesValues[1], TimeSpan.FromDays(1), sampledValues[2].LongTime), sampledValues[2].Close);

            Assert.AreEqual(seriesValues[0].Time.AddDays(3 * 0.25), sampledValues[3].Time);
            Assert.AreEqual(sampledValues[2].Close, sampledValues[3].Open);
            Assert.AreEqual(2.75, sampledValues[3].High);
            Assert.AreEqual(2.5, sampledValues[3].Low);
            Assert.AreEqual(InterpolateClose(seriesValues[1], seriesValues[1], TimeSpan.FromDays(1), sampledValues[3].LongTime), sampledValues[3].Close);

            Assert.AreEqual(seriesValues[0].Time.AddDays(4 * 0.25), sampledValues[4].Time);
            Assert.AreEqual(sampledValues[3].Close, sampledValues[4].Open);
            Assert.AreEqual(seriesValues[1].High, sampledValues[4].High);
            Assert.AreEqual(2.75, sampledValues[4].Low);
            Assert.AreEqual(seriesValues[1].Close, sampledValues[4].Close);

            // Second half:

            Assert.AreEqual(seriesValues[0].Time.AddDays(5 * 0.25), sampledValues[5].Time);
            Assert.AreEqual(seriesValues[2].Open, sampledValues[5].Open);
            Assert.AreEqual(seriesValues[2].High, sampledValues[5].High);
            Assert.AreEqual(3.75, sampledValues[5].Low);
            Assert.AreEqual(InterpolateClose(seriesValues[2], seriesValues[2], TimeSpan.FromDays(1), sampledValues[5].LongTime), sampledValues[5].Close);

            Assert.AreEqual(seriesValues[0].Time.AddDays(6 * 0.25), sampledValues[6].Time);
            Assert.AreEqual(sampledValues[5].Close, sampledValues[6].Open);
            Assert.AreEqual(3.75m, sampledValues[6].High);
            Assert.AreEqual(3.5m, sampledValues[6].Low);
            Assert.AreEqual(InterpolateClose(seriesValues[2], seriesValues[2], TimeSpan.FromDays(1), sampledValues[6].LongTime), sampledValues[6].Close);

            Assert.AreEqual(seriesValues[0].Time.AddDays(7 * 0.25), sampledValues[7].Time);
            Assert.AreEqual(sampledValues[6].Close, sampledValues[7].Open);
            Assert.AreEqual(3.5m, sampledValues[7].High);
            Assert.AreEqual(3.25m, sampledValues[7].Low);
            Assert.AreEqual(InterpolateClose(seriesValues[2], seriesValues[2], TimeSpan.FromDays(1), sampledValues[7].LongTime), sampledValues[7].Close);

            Assert.AreEqual(seriesValues[0].Time.AddDays(8 * 0.25), sampledValues[8].Time);
            Assert.AreEqual(sampledValues[7].Close, sampledValues[8].Open);
            Assert.AreEqual(3.25m, sampledValues[8].High);
            Assert.AreEqual(seriesValues[2].Low, sampledValues[8].Low);
            Assert.AreEqual(seriesValues[2].Close, sampledValues[8].Close);
        }

        [Test]
        public void SamplesCandlestickSeriesWithHigherSamplingResolutionDisabled()
        {
            // Original series is sampled at 1 day intervals
            // Sampled series is sampled at 0.25 day intervals
            //      Original series: |-------------------|-------------------|
            //      Sampled series:  |-------------------|-------------------|

            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            // even if the data doesn't fit exactly the expected bar span we expect it to pass through
            series.AddPoint(_reference.AddDays(1.6), 4m, 4m, 3m, 3m);

            var sampler = new SeriesSampler(TimeSpan.FromDays(0.25)) { SubSample = false };

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(2));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(3, sampled.Values.Count);

            Assert.AreEqual(seriesValues[0].Time, sampledValues[0].Time);
            AssertCandlesticksValuesAreEqual(seriesValues[0], sampledValues[0]);

            Assert.AreEqual(seriesValues[1].Time, sampledValues[1].Time);
            AssertCandlesticksValuesAreEqual(seriesValues[1], sampledValues[1]);

            Assert.AreEqual(seriesValues[2].Time, sampledValues[2].Time);
            AssertCandlesticksValuesAreEqual(seriesValues[2], sampledValues[2]);
        }

        [Test]
        public void SamplesCandlestickSeriesWithLowerSamplingResolutionNullValues()
        {
            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(2), 4m, 4m, 3m, 3m);
            series.AddPoint(new Candlestick(_reference.AddDays(3), null, null, null, null));
            // Time jump
            series.AddPoint(_reference.AddDays(11), 5m, 5m, 5m, 5m);

            var barSpan = TimeSpan.FromDays(1.5);
            var sampler = new SeriesSampler(barSpan);

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(12));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(8, sampled.Values.Count);

            var expectedTime = series.Values[3].Time;
            for (var i = 2; i < 7; i++)
            {
                Assert.AreEqual(expectedTime, sampledValues[i].Time);
                Assert.AreEqual(null, sampledValues[i].Open);
                Assert.AreEqual(null, sampledValues[i].High);
                Assert.AreEqual(null, sampledValues[i].Low);
                Assert.AreEqual(null, sampledValues[i].Close);
                expectedTime += barSpan;
            }

            Assert.AreEqual(expectedTime, sampledValues[7].Time);
            Assert.AreEqual(seriesValues[4].Open, sampledValues[7].Open);
            Assert.AreEqual(seriesValues[4].High, sampledValues[7].High);
            Assert.AreEqual(seriesValues[4].Low, sampledValues[7].Low);
            Assert.AreEqual(seriesValues[4].Close, sampledValues[7].Close);
        }

        [Test]
        public void SamplesCandlestickSeriesWithHigherSamplingResolutionNullValues()
        {
            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(2), 4m, 4m, 3m, 3m);
            series.AddPoint(new Candlestick(_reference.AddDays(3), null, null, null, null));
            // Time jump
            series.AddPoint(_reference.AddDays(10), 5m, 5m, 5m, 5m);

            var barSpan = TimeSpan.FromDays(0.5);
            var sampler = new SeriesSampler(barSpan);

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(10));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(21, sampled.Values.Count);

            var expectedTime = series.Values[2].Time;
            for (var i = 5; i < 19; i++)
            {
                expectedTime += barSpan;
                Assert.AreEqual(expectedTime, sampledValues[i].Time);
                Assert.AreEqual(null, sampledValues[i].Open);
                Assert.AreEqual(null, sampledValues[i].High);
                Assert.AreEqual(null, sampledValues[i].Low);
                Assert.AreEqual(null, sampledValues[i].Close);
            }

            expectedTime += barSpan;
            Assert.AreEqual(expectedTime, sampledValues[19].Time);
            Assert.AreEqual(seriesValues[4].Open, sampledValues[19].Open);
            Assert.AreEqual(seriesValues[4].High, sampledValues[19].High);
            Assert.AreEqual(seriesValues[4].Low, sampledValues[19].Low);
            Assert.AreEqual(seriesValues[4].Close, sampledValues[19].Close);

            expectedTime += barSpan;
            Assert.AreEqual(expectedTime, sampledValues[20].Time);
            Assert.AreEqual(seriesValues[4].Open, sampledValues[20].Open);
            Assert.AreEqual(seriesValues[4].High, sampledValues[20].High);
            Assert.AreEqual(seriesValues[4].Low, sampledValues[20].Low);
            Assert.AreEqual(seriesValues[4].Close, sampledValues[20].Close);
        }

        [Test]
        public void SamplesCandlestickSeriesWithHigherUnevenSamplingResolutionAndStopAfterLastPoint()
        {
            // Original series is sampled at 1 day intervals
            // Sampled series is sampled at 10 hours intervals
            //      Original series: |-------------------|-------------------|
            //      Sampled series:  |--------|--------|--------|--------|--------

            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(2), 4m, 4m, 3m, 3m);

            var sampler = new SeriesSampler(TimeSpan.FromHours(10));

            var sampled = sampler.Sample(series, _reference, _reference.AddDays(2));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(5, sampled.Values.Count);

            // First half:

            Assert.AreEqual(seriesValues[0].Time, sampledValues[0].Time);
            AssertCandlesticksValuesAreEqual(seriesValues[0], sampledValues[0]);

            Assert.AreEqual(seriesValues[0].Time.AddHours(1 * 10), sampledValues[1].Time);
            Assert.AreEqual(seriesValues[1].Open, sampledValues[1].Open);
            Assert.AreEqual(2.416667m, sampledValues[1].High);
            Assert.AreEqual(seriesValues[1].Low, sampledValues[1].Low);
            Assert.AreEqual((double)InterpolateClose(seriesValues[1], seriesValues[1], TimeSpan.FromDays(1), sampledValues[1].LongTime), (double)sampledValues[1].Close, delta: 1e-3);

            Assert.AreEqual(seriesValues[0].Time.AddHours(2 * 10), sampledValues[2].Time);
            Assert.AreEqual(sampledValues[1].Close, sampledValues[2].Open);
            Assert.AreEqual(2.833333m, sampledValues[2].High);
            Assert.AreEqual(2.416667m, sampledValues[2].Low);
            Assert.AreEqual((double)InterpolateClose(seriesValues[1], seriesValues[1], TimeSpan.FromDays(1), sampledValues[2].LongTime), (double)sampledValues[2].Close, delta: 1e-3);

            // Second half:

            Assert.AreEqual(seriesValues[0].Time.AddHours(3 * 10), sampledValues[3].Time);
            Assert.AreEqual(seriesValues[2].Open, sampledValues[3].Open);
            Assert.AreEqual(seriesValues[2].High, sampledValues[3].High);
            Assert.AreEqual(3.75m, sampledValues[3].Low);
            Assert.AreEqual((double)InterpolateClose(seriesValues[2], seriesValues[2], TimeSpan.FromDays(1), sampledValues[3].LongTime), (double)sampledValues[3].Close, delta: 1e-3);

            Assert.AreEqual(seriesValues[0].Time.AddHours(4 * 10), sampledValues[4].Time);
            Assert.AreEqual(sampledValues[3].Close, sampledValues[4].Open);
            Assert.AreEqual(3.75m, sampledValues[4].High);
            Assert.AreEqual(3.333333m, sampledValues[4].Low);
            Assert.AreEqual((double)InterpolateClose(seriesValues[2], seriesValues[2], TimeSpan.FromDays(1), sampledValues[4].LongTime), (double)sampledValues[4].Close, delta: 1e-3);
        }

        [Test]
        public void SamplesCandlestickSeriesWithHigherUnevenSamplingResolutionAndStopBeforeLastPoint()
        {
            // Original series is sampled at 1 day intervals
            // Sampled series is sampled at 10 hours intervals
            //      Original series: |-------------------|-------------------|
            //      Sampled series:  |--------|--------|--------|--------|

            var series = new CandlestickSeries { Name = "name" };
            series.AddPoint(_reference, 1m, 2m, 1m, 2m);
            series.AddPoint(_reference.AddDays(1), 2m, 3m, 2m, 3m);
            series.AddPoint(_reference.AddDays(2), 4m, 4m, 3m, 3m);

            var sampler = new SeriesSampler(TimeSpan.FromHours(10));

            var sampled = sampler.Sample(series, _reference, _reference.AddHours(40));

            var seriesValues = series.Values.Cast<Candlestick>().ToList();
            var sampledValues = sampled.Values.Cast<Candlestick>().ToList();

            Assert.AreEqual(5, sampled.Values.Count);

            Assert.AreEqual(5, sampled.Values.Count);

            // First half:

            Assert.AreEqual(seriesValues[0].Time, sampledValues[0].Time);
            AssertCandlesticksValuesAreEqual(seriesValues[0], sampledValues[0]);

            Assert.AreEqual(seriesValues[0].Time.AddHours(1 * 10), sampledValues[1].Time);
            Assert.AreEqual(seriesValues[1].Open, sampledValues[1].Open);
            Assert.AreEqual(2.416667m, sampledValues[1].High);
            Assert.AreEqual(seriesValues[1].Low, sampledValues[1].Low);
            Assert.AreEqual((double)InterpolateClose(seriesValues[1], seriesValues[1], TimeSpan.FromDays(1), sampledValues[1].LongTime), (double)sampledValues[1].Close, delta: 1e-3);

            Assert.AreEqual(seriesValues[0].Time.AddHours(2 * 10), sampledValues[2].Time);
            Assert.AreEqual(sampledValues[1].Close, sampledValues[2].Open);
            Assert.AreEqual(2.833333m, sampledValues[2].High);
            Assert.AreEqual(2.416667m, sampledValues[2].Low);
            Assert.AreEqual((double)InterpolateClose(seriesValues[1], seriesValues[1], TimeSpan.FromDays(1), sampledValues[2].LongTime), (double)sampledValues[2].Close, delta: 1e-3);

            // Second half:

            Assert.AreEqual(seriesValues[0].Time.AddHours(3 * 10), sampledValues[3].Time);
            Assert.AreEqual(seriesValues[2].Open, sampledValues[3].Open);
            Assert.AreEqual(seriesValues[2].High, sampledValues[3].High);
            Assert.AreEqual(3.75m, sampledValues[3].Low);
            Assert.AreEqual((double)InterpolateClose(seriesValues[2], seriesValues[2], TimeSpan.FromDays(1), sampledValues[3].LongTime), (double)sampledValues[3].Close, delta: 1e-3);

            Assert.AreEqual(seriesValues[0].Time.AddHours(4 * 10), sampledValues[4].Time);
            Assert.AreEqual(sampledValues[3].Close, sampledValues[4].Open);
            Assert.AreEqual(3.75m, sampledValues[4].High);
            Assert.AreEqual(3.333333m, sampledValues[4].Low);
            Assert.AreEqual((double)InterpolateClose(seriesValues[2], seriesValues[2], TimeSpan.FromDays(1), sampledValues[4].LongTime), (double)sampledValues[4].Close, delta: 1e-3);
        }

        private static void AssertCandlesticksValuesAreEqual(Candlestick first, Candlestick second)
        {
            Assert.AreEqual(first.Open, second.Open);
            Assert.AreEqual(first.High, second.High);
            Assert.AreEqual(first.Low, second.Low);
            Assert.AreEqual(first.Close, second.Close);
        }
    }
}