using ScottPlot;
using ScottPlot.WPF;

namespace OperationControl.Models
{
    public class GraficoModel
    {
        public GraficoModel(WpfPlot grafico)
        {
            Grafico = grafico;
        }

        private WpfPlot Grafico { get; set; }
        private bool EmUso { get; set; }
        private DateTime Tempo_Atual { get; set; }
        private DateTime? Tempo_Inicial { get; set; }
        private List<double> Eixo_X { get; set; }
        private List<List<double>> Eixo_Y { get; set; }
        private double Limite { get; set; }
        private List<GraficoParametrosModel> Parametros { get; set; }

        private void InicializarGrafico(List<GraficoParametrosModel> parametros)
        {
            Parametros = parametros;

            Grafico.Plot.ShowLegend(Alignment.UpperLeft);
            Eixo_X = new List<double>();
            Eixo_Y = new List<List<double>>();
            Parametros.ForEach(p =>
            {
                Eixo_Y.Add(new List<double>());
                p.Cor = GetNextColor();
            });
            Tempo_Inicial = Tempo_Atual;
            _colorIndex = 0;
            EmUso = true;
        }

        public void Atualizar(bool inicial, DateTime? t_atual, List<GraficoParametrosModel> parametros, double limite = 60)
        {
            Tempo_Atual = t_atual ?? DateTime.Now;
            Limite = limite;
            if (inicial)
                InicializarGrafico(parametros);
            Parametros.ForEach(p => p.Atualizar(parametros[Parametros.IndexOf(p)]));
            AtualizaDadosGrafico();
        }

        private void AtualizaDadosGrafico()
        {
            double tSegundos = (Tempo_Atual - Tempo_Inicial!.Value).TotalSeconds;

            Grafico.Plot.Clear();

            Eixo_X.Add(tSegundos);

            for (int i = 0; i < Parametros.Count; i++)
            {
                Eixo_Y[i].Add(Parametros[i].Valor ?? 0);
                var sc = Grafico.Plot.Add.Scatter(Eixo_X.ToArray(), Eixo_Y[i].ToArray());
                sc.Label = $"{Parametros[i].Label} {(Parametros[i].Valor ?? 0):0.00} {Parametros[i].Unidade}";
                sc.Color = Parametros[i].Cor;
                sc.LineWidth = 2;
            }

            while (Eixo_X.Count > Limite)
            {
                Eixo_X.RemoveAt(0);
                Eixo_Y.ForEach(x => x.RemoveAt(0));
            }

            double xEnd = Eixo_X[^1];
            double xStart = Math.Max(0, xEnd - Limite);
            Grafico.Plot.Axes.SetLimitsX(xStart, xEnd);

            Grafico.Plot.Axes.AutoScaleY();
            Grafico.Refresh();
        }

        public void Limpar(DateTime? t_atual)
        {
            if ((t_atual ?? DateTime.Now) > Tempo_Atual && EmUso)
            {
                Grafico.Plot.Clear();
                Grafico.Refresh();
                EmUso = false;
            }
        }

        private int _colorIndex = 0;
        private ScottPlot.Color GetNextColor()
        {
            var palette = ScottPlot.Palette.GetPalettes()[3];
            var colors = palette.Colors;

            var color = colors[_colorIndex % colors.Length];
            _colorIndex++;

            return color;
        }

        public class GraficoParametrosModel
        {
            public string Label { get; set; }
            public string Unidade { get; set; }
            public double? Valor { get; set; }
            public ScottPlot.Color Cor { get; set; }

            public void Atualizar(GraficoParametrosModel p)
            {
                Label = p.Label;
                Unidade = p.Unidade;
                Valor = p.Valor;
            }
        }

    }
}