using SteamWare;
using System;
using System.Web.UI;
using System.Web.UI.DataVisualization.Charting;
using System.Web.UI.WebControls;

namespace MoonPro.WebUserControls
{
    public partial class mod_sequencerTempiCiclo : System.Web.UI.UserControl
    {
        #region proprietà

        protected int _timeSplits = 10;
        protected double _minVal = 0.5;
        /// <summary>
        /// totale in minuti da plottare
        /// </summary>
        protected double totale = 1;
        /// <summary>
        /// valore minimo da plottare
        /// </summary>
        public double min2plot { get; set; }
        /// <summary>
        /// titolo del grafico
        /// </summary>
        public string titolo { get; set; }
        /// <summary>
        /// larghezza totale del grafico
        /// </summary>
        public int larghezza { get; set; }
        /// <summary>
        /// numero dei segmenti del grafico
        /// </summary>
        public int numSplit { get; set; }
        /// <summary>
        /// % minuma nel periodo per dire che sia verde
        /// </summary>
        public double minVal { get; set; }
        /// <summary>
        /// definisce se plottare "reversed" (ovvero i valori "minimi" sono con barre + alte dei massimi, come se vosse apssare da tempo a velocità...)
        /// </summary>
        public bool plotReversed { get; set; }
        /// <summary>
        /// altezza max grafico
        /// </summary>
        public int graphHeight { get; set; }

        #endregion

        /// <summary>
        /// caricamento pagina
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                // setup valori
                min2plot = 0.0;
                titolo = "TempiCiclo";
                doUpdate();
            }
        }
        /// <summary>
        /// disegna la tabella
        /// </summary>
        protected void plottaGrafico()
        {
            // a seconda del numero di eventi da plottare decido la procedura...
            DataLayer_generic.serieTimeValDataTable dati = _grafico.serieDati;
            try
            {
                // è la somma dei minuti totali dall'inizio alla fine...
                totale = ((TimeSpan)_grafico.intervallo.fine.Subtract(_grafico.intervallo.inizio)).TotalMinutes;
            }
            catch
            { }

            plottaDettaglio(dati);
        }

        /// <summary>
        /// popola il sequencer degli stati riportando tutti i singoli valori
        /// </summary>
        /// <param name="dati"></param>
        /// <returns></returns>
        private void plottaDettaglio(DataLayer_generic.serieTimeValDataTable dati)
        {
            // definizioni x chart
            Chart1.Width = larghezza;
            Chart1.AntiAliasing = System.Web.UI.DataVisualization.Charting.AntiAliasingStyles.All;
            Chart1.Height = graphHeight;
            // definizione intervallo asse Y (che qui è anche asse X...
            Chart1.ChartAreas["TempiCiclo"].AxisX.Minimum = _grafico.intervallo.inizio.ToOADate();
            Chart1.ChartAreas["TempiCiclo"].AxisX.Maximum = _grafico.intervallo.fine.ToOADate();
            LabelStyle lbst = new LabelStyle();
            lbst.Format = "HH:mm";
            Chart1.ChartAreas["TempiCiclo"].AxisX.LabelStyle = lbst;

            // definizioni x chart area tempi ciclo
            Chart1.ChartAreas["TempiCiclo"].AxisY.Enabled = System.Web.UI.DataVisualization.Charting.AxisEnabled.False;
            Chart1.ChartAreas["TempiCiclo"].AxisY.IsLogarithmic = false;
            Chart1.ChartAreas["TempiCiclo"].AxisY.IsReversed = true;


            string tipo_A = "";
            string tipo_B = "";
            decimal ratioTC;
            decimal deltaValori = grafico.maxVal - grafico.minVal;
            foreach (DataLayer_generic.serieTimeValRow riga in _grafico.serieDati)
            {

                ratioTC = riga.valore;

                // a seconda del tipo aggiungo all'una o all'altra serie...
                if (grafico.palletChange)
                {
                    // controllo per inizializzare i 2 tipi...
                    if (tipo_A == "")
                    {
                        tipo_A = riga.tipo;
                        if (Chart1.Series.Count < 1)
                        {
                            Chart1.Series.Add(tipo_A);
                        }
                    }
                    else if (tipo_B == "" && riga.tipo != tipo_A)
                    {
                        tipo_B = riga.tipo;
                        if (Chart1.Series.Count < 2)
                        {
                            // provo ad aggiungere nuova...
                            try
                            {
                                Chart1.Series.Add(tipo_B);
                            }
                            // ... sennò aggiungo vecchia serie
                            catch
                            {
                                Chart1.Series.Add(tipo_A);
                            }
                        }
                    }
                    // definisco colori
                    if (riga.tipo == tipo_A)
                    {
                        try
                        {
                            Chart1.Series[tipo_A].Points.AddXY(riga.DataEnd, ratioTC);
                        }
                        catch
                        {
                            Chart1.Series[0].Points.AddXY(riga.DataEnd, ratioTC);
                        }
                    }
                    else
                    {
                        try
                        {
                            Chart1.Series[tipo_B].Points.AddXY(riga.DataEnd, ratioTC);
                        }
                        catch
                        {
                            Chart1.Series[1].Points.AddXY(riga.DataEnd, ratioTC);
                        }
                    }
                }
                else // unica serie
                {
                    if (tipo_A == "")
                    {
                        tipo_A = riga.tipo;
                        if (Chart1.Series.Count < 1)
                        {
                            Chart1.Series.Add(tipo_A);
                        }
                    }
                    Chart1.Series[tipo_A].Points.AddXY(riga.DataEnd, ratioTC);
                }
            }

            if (Chart1.Series.Count > 0)
            {
                // disegno plot nuovo...
                try
                {
                    Chart1.Series[tipo_A].XValueType = ChartValueType.DateTime;
                    Chart1.Series[tipo_A].ChartType = SeriesChartType.FastPoint;
                }
                catch
                {
                    Chart1.Series[0].XValueType = ChartValueType.DateTime;
                    Chart1.Series[0].ChartType = SeriesChartType.FastPoint;
                }
                if (Chart1.Series.Count > 1)
                {
                    try
                    {
                        Chart1.Series[tipo_B].XValueType = ChartValueType.DateTime;
                        Chart1.Series[tipo_B].ChartType = SeriesChartType.FastPoint;
                    }
                    catch
                    {
                        Chart1.Series[1].XValueType = ChartValueType.DateTime;
                        Chart1.Series[1].ChartType = SeriesChartType.FastPoint;
                    }
                }
            }
        }
        /// <summary>
        /// calcola il rapporto tr ail valore e le grandezze reali dato masismo, intervallo, apdding, plot regolare o reversed...
        /// </summary>
        /// <param name="valore"></param>
        /// <param name="maxVal"></param>
        /// <param name="deltaValori"></param>
        /// <param name="plotReversed"></param>
        /// <returns></returns>
        protected decimal calcolaRatio(decimal valore, decimal maxVal, decimal deltaValori, bool plotReversed, decimal padding)
        {
            decimal answ = 0;
            if (plotReversed)
            {
                answ = (padding + ((1 - 2 * padding) * ((maxVal - valore) / (deltaValori))));
            }
            else
            {
                answ = (padding + ((1 - 2 * padding) * ((valore - maxVal) / (deltaValori))));
            }
            return answ;
        }

        /// <summary>
        /// intercetta richiesta di zoom e zoomma sul giorno in esame...
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void lnkb_Click(object sender, EventArgs e)
        {
            LinkButton lnk = (LinkButton)sender;
            // calcolo il giorno...
            Session["dataZoom"] = lnk.CommandArgument.ToString();//Convert.ToDateTime
            if (eh_richiestaZoom != null)
            {
                eh_richiestaZoom(this, new EventArgs());
            }
        }
        /// <summary>
        /// popola il sequencer degli stati raggruppando perché troppi valori secondo MEDIA ARMONICA
        /// </summary>
        /// <param name="dati"></param>
        /// <returns></returns>
        private void plottaGruppiMediaArmonica(DataLayer_generic.serieTimeValDataTable dati)
        {
            // creo oggetto x contenere i dati "mediati"
            DataLayer_generic.serieTimeValDataTable datiGrouped = new DataLayer_generic.serieTimeValDataTable();
            // calcolo il val minimo da plottare (come ampiezza)
            decimal ampiezzaMin = (decimal)totale / numSplit;
            // setup valori iniziali
            decimal valoreCurr = (decimal)0.0;
            decimal valoreMedio = (decimal)1.0;
            DateTime timeRaggiunto = _grafico.intervallo.inizio;
            decimal ampiezzaCurr = (decimal)0.0;
            decimal ampiezzaMedia = (decimal)0.0;
            string label = "";
            // ciclo x tutti i record
            foreach (DataLayer_generic.serieTimeValRow riga in dati)
            {
                // calcolo nuova ampiezza
                ampiezzaCurr = (decimal)((TimeSpan)riga.DataEnd.Subtract(riga.DataStart)).TotalMinutes;
                //...e calcolo nuovo valore medio...
                valoreCurr = riga.valore;
                // calcolo media armonica
                valoreMedio = ((ampiezzaCurr + ampiezzaMedia) / (ampiezzaMedia / valoreMedio + ampiezzaCurr / valoreCurr));
                ampiezzaMedia = ampiezzaCurr + ampiezzaMedia;
                // se supero il limite aggiungo in tabella, sennò proseguo...
                if (ampiezzaMedia > ampiezzaMin)
                {
                    label = string.Format("TC: {0} min/pz", valoreMedio);
                    datiGrouped.AddserieTimeValRow(timeRaggiunto, riga.DataEnd, valoreMedio, label, "TC");
                    // resetto
                    timeRaggiunto = riga.DataEnd;
                    ampiezzaMedia = (decimal)0.0;
                    valoreMedio = (decimal)1.0;
                }
            }
            _grafico.palletChange = false;
            plottaDettaglio(datiGrouped);
        }
        /// <summary>
        /// restituisce true se ci sono dati...
        /// </summary>
        /// <returns></returns>
        protected bool datiPresenti()
        {
            bool answ = false;
            try
            {
                int numCelle = grafico.serieDati.Rows.Count;
                answ = (numCelle > 0);
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// oggetto protected
        /// </summary>
        protected objTempiCiclo _grafico;
        /// <summary>
        /// elemento grafico da plottare
        /// </summary>
        public objTempiCiclo grafico
        {
            get
            {
                return _grafico;
            }
            set
            {
                _grafico = value;
            }
        }

        /// <summary>
        /// aggiorna il controllo
        /// </summary>
        public void doUpdate()
        {
            if (datiPresenti())
            {
                plottaGrafico();
            }
            else
            {
                // non plotto
            }
        }

        /// <summary>
        /// evento di richeista zoom sui dati
        /// </summary>
        public event EventHandler eh_richiestaZoom;
        /// <summary>
        /// evento di click x zoom
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Chart1_Click(object sender, ImageMapEventArgs e)
        {
            // alzo evento
            if (eh_richiestaZoom != null)
            {
                eh_richiestaZoom(this, new EventArgs());
            }
        }


    }
}