using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MathNet.Numerics.Interpolation;
using MathNet.Numerics.LinearRegression;
using System.IO;
using MathNet.Numerics;

namespace ClockDriftAnalyzer
{
    class Program
    {
        class Sample
        {
            public uint Epoch { get; set; }
            public uint Time { get; set; }
            public DateTime Reference { get; set; }
        }

        static void Main(string[] args)
        {
            var samples = new List<Sample>();

            using (var reader = new BinaryReader(File.OpenRead(@"E:\testdata\clock1.raw")))
            {
                while (reader.BaseStream.Position < reader.BaseStream.Length)
                {
                    samples.Add(new Sample()
                    {
                        Epoch = reader.ReadUInt32(),
                        Time = reader.ReadUInt32(),
                        Reference = DateTime.FromBinary(reader.ReadInt64())
                    });
                }
            }
            var initRef = samples.First().Reference;
            var initTime = samples.First().Time;
            var initEpoch = samples.First().Epoch;

            var samplesRelat = samples.Select(s => new {
                Epoch = s.Epoch - initEpoch,
                Time = s.Time - initTime,
                Ref = s.Reference - initRef
            }).ToArray();

            using (TextWriter writer = new StreamWriter(@"E:\testdata\dump.txt"))
            {
                foreach (var sample in samplesRelat)
                {
                    writer.WriteLine("{0}\t{1}\t{2}", sample.Epoch, sample.Time, sample.Ref);
                }
            }

            var refVsTime = samplesRelat.Select(s => new Tuple<double, double>(s.Ref.TotalMilliseconds, s.Time));
            var spline = SimpleRegression.Fit(refVsTime);
            Console.WriteLine("Лин.регрессия, коэф A: {0:0.0000}", spline.Item2);
            var last = refVsTime.Last();
            Console.WriteLine("Расхождение в конце: {0:0.0} с", (last.Item2 - last.Item1) / 1000.0);

            var rs = GoodnessOfFit.RSquared(refVsTime.Select(t => t.Item1 * spline.Item2), refVsTime.Select(t => t.Item2));
            Console.WriteLine("R^2: {0}", rs);

            var refVsCurTime = samplesRelat
                .Select(s => new Tuple<double, uint>(s.Ref.TotalSeconds, s.Epoch))
                .DistinctBy(s => s.Item2)
                .ToArray();

            var ordered = refVsCurTime.Pairwise().OrderBy(t => t.Item2.Item1 - t.Item1.Item1);

            Console.WriteLine("\r\nНаименьшие шаги CurTimeEx:");
            foreach (var e in ordered.Take(20))
            {
                Console.WriteLine("Ref: {0:0.0} - {1:0.0}, CurTime: {2} - {3}", e.Item1.Item1, e.Item2.Item1, e.Item1.Item2, e.Item2.Item2);
            }

            Console.WriteLine("\r\nНаибольшие шаги CurTimeEx:");
            foreach (var e in ordered.Reverse().Where(e => samplesRelat.Reverse().SkipWhile(s => s.Epoch != e.Item2.Item2).TakeWhile(s => s.Epoch != e.Item1.Item2).Count() > 1).Take(20))
            {
                Console.WriteLine("Ref: {0:0.0} - {1:0.0}, CurTime: {2} - {3}", e.Item1.Item1, e.Item2.Item1, e.Item1.Item2, e.Item2.Item2);
            }
        }
    }

    static class Extensions
    {
        public static IEnumerable<TSource> DistinctBy<TSource, TKey>
            (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            HashSet<TKey> knownKeys = new HashSet<TKey>();
            foreach (TSource element in source)
            {
                if (knownKeys.Add(keySelector(element)))
                {
                    yield return element;
                }
            }
        }

        public static IEnumerable<Tuple<T, T>> Pairwise<T>(this IEnumerable<T> source)
        {
            return source.Zip(source.Skip(1), (a, b) => Tuple.Create(a, b));
        }
    }
}