using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.DispenserAnalyzer.UI.Analysis;
using Tango.DispenserAnalyzer.UI.Models;

namespace Tango.DispenserAnalyzer.UI.Analyzers
{
    [Analyzer("dynamic")]
    public class DynamicSealingAnalzyer : IDispenserDispenserAnalyser
    {
        private IReader<DispenserSample> _reader;
        public IReader<DispenserSample> Reader
        {
            get { return _reader; }
            set { _reader = value; }
        }
        public DynamicSealingAnalzyer()
        {
            Reader = new DispenserReader();
        }

        public Task<List<IAnalyzerResult>> Process(List<DispenserSample> csvRows, bool backgroundMode)
        {
            return Task.Factory.StartNew<List<IAnalyzerResult>>(() =>
            {
                List<IAnalyzerResult> results = new List<IAnalyzerResult>();
                List<DispenserSample> commands = csvRows.Where(x => x.Command != null && x.Command.ToLower().Contains("label")).ToList<DispenserSample>();
                
                var pairs = commands.Select((x, i) => new { Index = i, Value = x }).GroupBy(x => x.Index / 2).Select(x => x.Select(v => v.Value).ToList()).ToList();
                
                //dynamic  test
                if (pairs.Count > 0 && pairs[0].Count > 1)
                {
                    DynamicSealingAnalyzerResult result = new DynamicSealingAnalyzerResult();
                    List<DispenserSample> rangeTestValues = csvRows.Where(x => x.Index > pairs[0][0].Index && x.Index < pairs[0][1].Index).ToList();
                    int period = 10;
                    result.Result = AnalyzerResultValue.Passed;
                    //var sum_average = Enumerable.Range(0, rangeTestValues.Count - period).Select(n => rangeTestValues.Select(x=>x.Pressure).Skip(n).Take(periodLength).Average()).ToList();
                    for (int counter = 0; counter <= rangeTestValues.Count - period; )
                    {
                        var sum1 = rangeTestValues.Skip(counter++).Take(period).Average(t => t.Pressure);
                        var sum2 = rangeTestValues.Skip(counter++).Take(period).Average(t => t.Pressure);
                        if(sum1 > sum2 && sum1 - sum2 > 8)
                        {
                            result.DynamicSealingResult = "test failed";
                            result.Result = AnalyzerResultValue.Failed;
                            break;
                        }
                    }
                    results.Add(result);
                }
                SealingAnalyzerResult sealingAnalyzerResult = new SealingAnalyzerResult();
                //start sealing test
                if (pairs.Count > 1 && pairs[1].Count > 1)
                {
                    List<DispenserSample> rangeStartTestValues = csvRows.Where(x => x.Index > pairs[1][0].Index && x.Index < pairs[1][1].Index).ToList();
                    sealingAnalyzerResult.AverageStartTestValue = rangeStartTestValues.Average(t => t.Pressure);
                }
                //end sealing of test
                if (pairs.Count > 2 && pairs[2].Count > 1)
                {
                    List<DispenserSample> rangeEndTestValues = csvRows.Where(x => x.Index > pairs[2][0].Index && x.Index < pairs[2][1].Index).ToList();
                    sealingAnalyzerResult.AverageEndTestValue = rangeEndTestValues.Average(t => t.Pressure);
                }
                sealingAnalyzerResult.AbsoluteTestValue = Math.Abs(sealingAnalyzerResult.AverageEndTestValue - sealingAnalyzerResult.AverageStartTestValue);
                sealingAnalyzerResult.Result = sealingAnalyzerResult.AbsoluteTestValue < 8 ? AnalyzerResultValue.Passed : AnalyzerResultValue.Failed;
                results.Add(sealingAnalyzerResult);
                return results;
            });
        }

        public void GetPoints(List<DispenserSample> samples, IList<OxyPlot.DataPoint> points)
        {
            samples.ForEach(x =>
            {
                if (x.Pressure != 0.0)
                { points.Add(new OxyPlot.DataPoint(x.Index, x.Pressure)); }
            });
        }

        public bool ShowChartAfterProcess { get { return true; } }

        public bool AvailableCompareResults { get { return false; } }

        public class DynamicSealingAnalyzerResult : AnalyzerResultBase
        {
            [Description("Dynamic sealing result")]
            public string DynamicSealingResult { get; set; }
            
            public DynamicSealingAnalyzerResult()
            {
                DynamicSealingResult = "test succeed";
                Result = AnalyzerResultValue.Undetermined;
            }
        }
    }
}