using GPW_data;
using SteamWare;
using System;
using System.Collections.Generic;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace GPW.WebUserControls
{
    public partial class mod_commAttivita : System.Web.UI.UserControl
    {
        #region Private Properties

        private bool checkLicOk
        {
            get => licenzeGPW.checkLicenze && licenzeGPW.checkPayload;
        }

        #endregion Private Properties

        #region Protected Properties

        /// <summary>
        /// Hash di base x ricerca CLIENTE da idxFase
        /// </summary>
        protected string rhCliByIF { get; set; }

        /// <summary>
        /// Hash di base x ricerca FASE da idxFase
        /// </summary>
        protected string rhFaseByIF { get; set; }

        /// <summary>
        /// Hash di base x ricerca IdxProgetto da idxFase
        /// </summary>
        protected string rhIPByIF { get; set; }

        /// <summary>
        /// Hash di base x ricerca PROGETTO da idxFase
        /// </summary>
        protected string rhProjByIF { get; set; }

        protected bool userEnabled { get; set; } = false;

        #endregion Protected Properties

        #region Public Properties

        /// <summary>
        /// idxDipendente in sessione
        /// </summary>
        public static int idxDipendenteCurr
        {
            get
            {
                int idx = 0;
                try
                {
                    idx = memLayer.ML.IntSessionObj("IdxDipendente");
                }
                catch
                { }
                return idx;
            }
            set
            {
                memLayer.ML.setSessionVal("idxDipendente", value);
            }
        }

        /// <summary>
        /// data riferimento (selezionata) da session
        /// </summary>
        public DateTime dataRif
        {
            get
            {
                DateTime answ = DateTime.Now;
                // cerco in session...
                if (memLayer.ML.isInSessionObject("dataRif"))
                {
                    try
                    {
                        answ = Convert.ToDateTime(memLayer.ML.objSessionObj("dataRif"));
                    }
                    catch
                    { }
                }
                // altrimenti cerco in URL e salvo in session...
                else if (!string.IsNullOrEmpty(memLayer.ML.QSS("dataRif")))
                {
                    answ = memLayer.ML.QSD("dataRif");
                    dataRif = answ;
                }
                // restituisco!
                return answ;
            }
            set
            {
                memLayer.ML.setSessionVal("dataRif", value);
            }
        }

        /// <summary>
        /// pagina di return a fine editing
        /// </summary>
        public string returnPage
        {
            get
            {
                string answ = memLayer.ML.confReadString("baseUrl");
                try
                {
                    answ = memLayer.ML.StringSessionObj("returnPage");
                }
                catch
                { }
                return answ;
            }
            set
            {
                memLayer.ML.setSessionVal("returnPage", value);
            }
        }

        #endregion Public Properties

        #region Private Methods

        /// <summary>
        /// Cerca dati cliente da idxFase su DB
        /// </summary>
        /// <param name="idxFase"></param>
        /// <returns></returns>
        private string getCliByDb(int idxFase)
        {
            string answ = "";
            try
            {
                int idxPrj = idxProjByIdxFase(idxFase);
                DS_Applicazione.AnagProgettiRow progetto = DataProxy.DP.taAP.getByIdxProjSmart(idxPrj)[0];
                answ = DataProxy.DP.taAnCli.getByIdx(progetto.idxCliente)[0].RagSociale;
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Cerca dati fase da idxFase su DB
        /// </summary>
        /// <param name="idxFase"></param>
        /// <returns></returns>
        private string getFaseByDb(int idxFase)
        {
            string answ = "";
            try
            {
                DS_Applicazione.AnagFasiRow fase = DataProxy.DP.taAF.getByIdxSmart(idxFase)[0];
                answ = string.Format("{0} <i>({1})</i>", fase.nomeFase, fase.descrizioneFase);
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Cerca dati progetto da idxFase su DB
        /// </summary>
        /// <param name="idxFase"></param>
        /// <returns></returns>
        private string getProjByDb(int idxFase)
        {
            string answ = "";
            try
            {
                int idxPrj = idxProjByIdxFase(idxFase);
                DS_Applicazione.AnagProgettiRow progetto = DataProxy.DP.taAP.getByIdxProjSmart(idxPrj)[0];
                answ = progetto.nomeProj;
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// imposta la pagina
        /// </summary>
        private void setupPage()
        {
            // salvo dataFrom/To x visualizzazione attivita
            txtData.Text = dataRif.ToString("yyyy-MM-dd");
            // recupero dati della commessa utente giornaliera...
            try
            {
                int maxErrMinus = memLayer.ML.confReadInt("maxErrMinus");
                int maxErrPlus = memLayer.ML.confReadInt("maxErrPlus");
                DS_Applicazione.v_logCommUtRow rigaLog = DataProxy.DP.taLCU.getByIdxDipDate(idxDipendenteCurr, dataRif, dataRif.AddDays(1), maxErrMinus, maxErrPlus)[0];
                lblTotOreRA.Text = string.Format("<b>{0:0.##}</b> / <b>{1:0.##}</b> h", rigaLog.h_com, rigaLog.h_lav);
            }
            catch
            {
                lblTotOreRA.Text = "...";
            }
            memLayer.ML.setSessionVal("dataFromRA", dataRif.Date);
            memLayer.ML.setSessionVal("dataToRA", dataRif.AddDays(1).Date);
            // controllo aggiunta da licenza
            var licOk = userEnabled;
            lnkCreateNew.Visible = licOk;
            divAlertLic.Visible = !licOk;
        }

        #endregion Private Methods

        #region Protected Methods

        /// <summary>
        /// Cerca associazione idxProj <--> idxFase da cache o da Db
        /// </summary>
        /// <param name="idxFase"></param>
        /// <returns></returns>
        protected int idxProjByIdxFase(int idxFase)
        {
            int idxPrj = 0;
            string answ = memLayer.ML.getRSV($"{rhIPByIF}{idxFase}");
            if (!string.IsNullOrEmpty(answ))
            {
                // cerco di convertire!
                int.TryParse(answ, out idxPrj);
            }
            if (idxPrj == 0)
            {
                DS_Applicazione.AnagFasiRow fase = DataProxy.DP.taAF.getByIdxSmart(idxFase)[0];
                idxPrj = Convert.ToInt32(fase.idxProgetto);
                memLayer.ML.setRSV($"{rhIPByIF}{idxFase}", idxPrj.ToString(), memLayer.ML.CRI("shotTimeCache"));
            }
            return idxPrj;
        }

        /// <summary>
        /// rimanda ad edit
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void lnkClona_Click(object sender, EventArgs e)
        {
            if (userEnabled)
            {
                // salvo
                LinkButton lbtn = (LinkButton)sender;
                int idxRa = 0;
                try
                {
                    idxRa = Convert.ToInt32(lbtn.CommandArgument);
                }
                catch
                { }
                // chiamo clona!
                DataProxy.DP.taRA.clonaRecord(idxRa);
            }
            //update!
            setupPage();
            grView.DataBind();
        }

        protected void lnkCreateNew_Click(object sender, EventArgs e)
        {
            memLayer.ML.emptySessionVal("idxRASel");
            if (userEnabled)
            {
                // redirect!
                Response.Redirect("attivitaIns.aspx");
            }
        }

        /// <summary>
        /// rimanda ad edit
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void lnkEdit_Click(object sender, EventArgs e)
        {
            // salvo
            LinkButton lbtn = (LinkButton)sender;
            if (userEnabled)
            {
                memLayer.ML.setSessionVal("idxRASel", lbtn.CommandArgument);
                // redirect!
                Response.Redirect("attivitaIns.aspx");
            }
        }

        protected void Page_Load(object sender, EventArgs e)
        {
            userEnabled = DataProxy.currDipIsActive && checkLicOk && DataProxy.currDipHasPayloadActive;
            if (!Page.IsPostBack)
            {
                // controllo se ho una data selezionata da URL
                if (!string.IsNullOrEmpty(memLayer.ML.QSS("dataRif")))
                {
                    dataRif = memLayer.ML.QSD("dataRif");
                }
                setupPage();
            }
            rhCliByIF = memLayer.ML.redHash("cliByIdxFase:");
            rhIPByIF = memLayer.ML.redHash("idxProjByIdxFase:");
            rhProjByIF = memLayer.ML.redHash("projByIdxFase:");
            rhFaseByIF = memLayer.ML.redHash("faseByIdxFase:");
            grView.DataBind();
        }

        protected void txtData_TextChanged(object sender, EventArgs e)
        {
            DateTime newData = DateTime.Today;
            DateTime.TryParse(txtData.Text, out newData);
            dataRif = newData;
            setupPage();
            grView.DataBind();
        }

        #endregion Protected Methods

        #region Public Methods

        /// <summary>
        /// recupera cliente da idxFase
        /// </summary>
        /// <param name="idxFase"></param>
        /// <returns></returns>
        public string cliByIdxFase(object _idxFase)
        {
            string answ = "";
            int idxFase = 0;
            int.TryParse(_idxFase.ToString(), out idxFase);
            answ = memLayer.ML.getRSV($"{rhCliByIF}{idxFase}");
            if (string.IsNullOrEmpty(answ))
            {
                answ = getCliByDb(idxFase);
                memLayer.ML.setRSV($"{rhCliByIF}{idxFase}", answ, memLayer.ML.CRI("shotTimeCache"));
            }
            return answ;
        }

        /// <summary>
        /// recupera descrizione e nome fase da idxFase
        /// </summary>
        /// <param name="idxFase"></param>
        /// <returns></returns>
        public string faseByIdx(object _idxFase)
        {
            string answ = "";
            int idxFase = 0;
            int.TryParse(_idxFase.ToString(), out idxFase);
            answ = memLayer.ML.getRSV($"{rhFaseByIF}{idxFase}");
            if (string.IsNullOrEmpty(answ))
            {
                answ = getFaseByDb(idxFase);
                memLayer.ML.setRSV($"{rhFaseByIF}{idxFase}", answ, memLayer.ML.CRI("shotTimeCache"));
            }
            return answ;
        }

        /// <summary>
        /// recupera progetto da idxFase
        /// </summary>
        /// <param name="idxFase"></param>
        /// <returns></returns>
        public string prjByIdxFase(object _idxFase)
        {
            string answ = "";
            int idxFase = 0;
            int.TryParse(_idxFase.ToString(), out idxFase);
            answ = memLayer.ML.getRSV($"{rhProjByIF}{idxFase}");
            if (string.IsNullOrEmpty(answ))
            {
                answ = getProjByDb(idxFase);
                memLayer.ML.setRSV($"{rhProjByIF}{idxFase}", answ, memLayer.ML.CRI("shotTimeCache"));
            }
            return answ;
        }

        #endregion Public Methods
    }
}