using LiveCharts;
using LiveCharts.Wpf;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media;
using Tango.BL;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core.Helpers;
using Tango.MachineStudio.Common;
using Tango.MachineStudio.Statistics.Models;

namespace Tango.MachineStudio.Statistics.ViewModels
{
    public class MainViewVM : StudioViewModel
    {
        private ObservablesContext _context;
        private List<JobRun> _job_runs;
        private bool rendered;

        private LabeledSeriesCollection _timelineJobStatusSeries;
        public LabeledSeriesCollection TimelineJobStatusSeries
        {
            get { return _timelineJobStatusSeries; }
            set { _timelineJobStatusSeries = value; RaisePropertyChangedAuto(); }
        }

        private LabeledSeriesCollection _pieJobFailedReasons;
        public LabeledSeriesCollection PieJobFailedReasons
        {
            get { return _pieJobFailedReasons; }
            set { _pieJobFailedReasons = value; RaisePropertyChangedAuto(); }
        }

        public MainViewVM()
        {

        }

        public override void OnApplicationReady()
        {
            Task.Factory.StartNew(() =>
            {
                _context = ObservablesContext.CreateDefault();
                DateTime start_date = DateTime.UtcNow.AddMonths(-1);
                _job_runs = _context.JobRuns.OrderBy(x => x.StartDate).ToList();
            });
        }

        private List<JobRun> GetJobRunsByStartDate(DateTime startDate, JobRunStatus? status = null)
        {
            return _job_runs.Where(x => x.StartDate.ToLocalTime() >= startDate && (status == null || x.JobRunStatus == status)).ToList();
        }

        private List<JobRun> GetJobRunsByDate(DateTime date, JobRunStatus? status = null)
        {
            return _job_runs.Where(x => x.StartDate.ToLocalTime().Date == date.Date && (status == null || x.JobRunStatus == status)).ToList();
        }

        private IEnumerable<DateTime> CreateDates(DateTime start, DateTime end)
        {
            for (DateTime date = start.Date; date.Date <= end.Date; date = date.AddDays(1))
            {
                yield return date;
            }
        }

        public override void OnNavigatedTo()
        {
            base.OnNavigatedTo();

            if (rendered) return;

            rendered = true;

            InvokeUIOnIdle(() =>
            {
                if (_job_runs.Count > 0)
                {
                    GenerateTimelineJobStatusChart();
                    GeneratePieFailedReasonsChart();
                }
            });
        }

        private void GenerateTimelineJobStatusChart()
        {
            TimelineJobStatusSeries = new LabeledSeriesCollection()
            {
                Title = "This Month Job Runs Status",
                ChartTitle = "Number Of Runs",
                LabelsTitle = "Date",
                SeriesColors = new List<Color>()
                    {
                         Colors.Green,
                         Colors.Orange,
                         Colors.Red,
                    },
            };

            var completed_job_runs = new ColumnSeries()
            {
                Title = "Completed",
                Values = new ChartValues<int>(),
                Fill = Brushes.Green,
            };
            var aborted_job_runs = new ColumnSeries()
            {
                Title = "Aborted",
                Values = new ChartValues<int>(),
                Fill = Brushes.Orange,
            };
            var failed_job_runs = new ColumnSeries()
            {
                Title = "Failed",
                Values = new ChartValues<int>(),
                Fill = Brushes.Red,
            };

            foreach (var date in CreateDates(DateTime.Now.AddMonths(-1), DateTime.Now))
            {
                completed_job_runs.Values.Add(GetJobRunsByDate(date, JobRunStatus.Completed).Count());
                aborted_job_runs.Values.Add(GetJobRunsByDate(date, JobRunStatus.Aborted).Count());
                failed_job_runs.Values.Add(GetJobRunsByDate(date, JobRunStatus.Failed).Count());

                TimelineJobStatusSeries.Labels.Add(date.ToShortDateString());
            }

            TimelineJobStatusSeries.SeriesCollection.Add(completed_job_runs);
            TimelineJobStatusSeries.SeriesCollection.Add(aborted_job_runs);
            TimelineJobStatusSeries.SeriesCollection.Add(failed_job_runs);
        }

        private void GeneratePieFailedReasonsChart()
        {
            var groups = GetJobRunsByStartDate(DateTime.Now.AddMonths(-1), JobRunStatus.Failed).GroupBy(x => x.FailedMessage).OrderBy(x => x.Count());

            List<Color> colors = new List<Color>();

            int max = groups.Max(x => x.Count());

            for (int i = 0; i < groups.Count(); i++)
            {
                int count = groups.ElementAt(i).Count();
                double alpha = Math.Max(((double)(count) / max * 200), 20);
                colors.Add(Color.FromArgb((byte)alpha, 200, 0, 0));
            }

            PieJobFailedReasons = new LabeledSeriesCollection()
            {
                Title = "This Month Job Failure Reasons",
                SeriesColors = colors,
            };

            int index = 0;

            foreach (var group in groups)
            {
                int count = group.Count();

                var series = new PieSeries()
                {
                    Title = group.First().FailedMessage,
                    Values = new ChartValues<int>() { count },
                    Fill = new SolidColorBrush(colors[index++]),
                    DataLabels = true,
                    ToolTip = group.First().FailedMessage,
                };

                PieJobFailedReasons.SeriesCollection.Add(series);
            }
        }
    }
}