using GMW_data;
using SteamWare;
using System;
using System.Web.UI;

namespace GMW.WebUserControls
{
    public partial class mod_sbloccoUdc : System.Web.UI.UserControl
    {
        /// <summary>
        /// flusso associato (hard coded) a UDC
        /// </summary>
        public string flusso
        {
            get
            {
                return hfFlusso.Value;
            }
            set
            {
                hfFlusso.Value = value;
            }
        }
        /// <summary>
        /// stato associato (hard coded) a  UDC
        /// </summary>
        public string statoUDC
        {
            get
            {
                return hfStatoUdc.Value;
            }
            set
            {
                hfStatoUdc.Value = value;
            }
        }
        /// <summary>
        /// tipo di evento associato alla modifica dell'UDC
        /// </summary>
        public string eventoUDC
        {

            get
            {
                return hfEvento.Value;
            }
            set
            {
                hfEvento.Value = value;
            }
        }
        /// <summary>
        /// Posizione di riferimento UDC in ingresso
        /// </summary>
        public int idxPosizioneIn
        {
            get
            {
                return Convert.ToInt32(hfIdxPosizione.Value);
            }
            set
            {
                hfIdxPosizione.Value = value.ToString();
            }
        }
        /// <summary>
        /// Posizione PERMESSA per (Eventuali) UDC in relazione a quello di cui si chiede sblocco
        /// </summary>
        public int idxPosizioneChildOk
        {
            get
            {
                return Convert.ToInt32(hfIdxPosizioneChildOk.Value);
            }
            set
            {
                hfIdxPosizioneChildOk.Value = value.ToString();
            }
        }
        /// <summary>
        /// Cod Blocco di riferimento
        /// </summary>
        public string codBloccoIn
        {
            get
            {
                return hfCodBlocco.Value;
            }
            set
            {
                hfCodBlocco.Value = value;
            }
        }

        public event EventHandler eh_reqUpdate;
        /// <summary>
        /// stringa UID univoca
        /// </summary>
        public string uid
        {
            get
            {
                return this.UniqueID.Replace("$", "_").Replace("-", "_");
            }
        }
        /// <summary>
        /// caricamento pagina
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                traduciObj();
                divSblocca.Visible = false;
                idxCella = Postazione.currIdxCella;
            }
            doChecks();
        }
        /// <summary>
        /// IDX cella associata alla linea corrente
        /// </summary>
        protected int idxCella
        {
            get
            {
                int answ = 0;
                if (memLayer.ML.isInSessionObject(string.Format("IdxCellaLinea_{0}", uid)))
                {
                    answ = memLayer.ML.IntSessionObj(string.Format("IdxCellaLinea_{0}", uid));
                }
                return answ;
            }
            set
            {
                memLayer.ML.setSessionVal(string.Format("IdxCellaLinea_{0}", uid), value);
            }
        }
        /// <summary>
        /// effettua controlli visibilità
        /// </summary>
        private void doChecks()
        {
            checkBarcode();
        }
        /// <summary>
        /// sistemo labels oggetti
        /// </summary>
        private void traduciObj()
        {
        }
        /// <summary>
        /// restituisce il nome della pagina corrente
        /// </summary>
        protected string PagCorrente
        {
            get
            {
                string answ = "";
                Uri MyUrl = Request.Url;
                string delimStr = "/";
                char[] delimiter = delimStr.ToCharArray();
                string[] finalUrl = MyUrl.LocalPath.ToString().Split(delimiter);
                int n = finalUrl.Length;
                answ = finalUrl[n - 1].ToString();
                DataLayer_AnagGen.PermessiRow riga = (DataLayer_AnagGen.PermessiRow)user_std.UtSn.permessi.Select(string.Format("URL = '{0}'", answ))[0];
                answ = riga.NOME;
                return answ;
            }
        }
        /// <summary>
        /// wrapper traduzione
        /// </summary>
        /// <param name="lemma"></param>
        /// <returns></returns>
        public string traduci(object lemma)
        {
            return user_std.UtSn.Traduci(lemma.ToString());
        }
        /// <summary>
        /// indica il codice articolo correntemente selezionato
        /// </summary>
        protected string currParticolare
        {
            get
            {
                return memLayer.ML.StringSessionObj(string.Format("currParticolare_{0}", uid));
            }
            set
            {
                memLayer.ML.setSessionVal(string.Format("currParticolare_{0}", uid), value, memLayer.ML.confReadBool("keepParticolareSel"));
            }
        }
        /// <summary>
        /// indica UDC correntemente selezionato
        /// </summary>
        protected string currUDC
        {
            get
            {
                return memLayer.ML.StringSessionObj(string.Format("UDC_{0}", uid));
            }
            set
            {
                memLayer.ML.setSessionVal(string.Format("UDC_{0}", uid), value, memLayer.ML.confReadBool("keepParticolareSel"));
            }
        }
        /// <summary>
        /// indica se i caratteri vadano forzati a maiuscoli
        /// </summary>
        public bool forceUppercase
        {
            get
            {
                return memLayer.ML.confReadBool("forceUppercase");
            }
        }
        /// <summary>
        /// decodifica il tipo barcode acquisito
        /// </summary>
        public tipoCodiceBarcode tipoBCode
        {
            get
            {
                tipoCodiceBarcode answ = tipoCodiceBarcode.ND;
                int trovati = 0;
                // controllo non si tratti di un comando...
                string preCmd = memLayer.ML.AppConf["prefComandi"];
                if (barcodeIn.StartsWith(preCmd))
                {
                    answ = tipoCodiceBarcode.Comando;
                }
                else if ((TermClass.Ter.riconosciBarcode(barcodeIn) == tipoCodiceBarcode.Particolare)) // è un particolare...
                {
                    answ = tipoCodiceBarcode.Particolare;
                }
                else
                {
                    try
                    {
                        // cerco tra gitterbox (UDC)...
                        trovati = MagClass.magazzino.taCartellini.getByUdc(barcodeIn).Rows.Count;
                        if (trovati > 0)
                        {
                            answ = tipoCodiceBarcode.UDC;
                        }
                    }
                    catch
                    {
                    }
                }
                return answ;
            }
        }
        /// <summary>
        /// valore barcode
        /// </summary>
        public string barcodeIn
        {
            get
            {
                return txtBarcode.Text.Trim();
            }
            set
            {
                txtBarcode.Text = value;
            }
        }
        /// <summary>
        /// controlla se ci sia un barcode
        /// </summary>
        private void checkBarcode()
        {
            if (barcodeIn != "")
            {
                Postazione.messaggiText = string.Format("Barcode digitato: {0}", barcodeIn);
                switch (tipoBCode)
                {
                    case tipoCodiceBarcode.UDC:
                        // procedo solo se UDC esistente
                        if (MagClass.magazzino.checkUDC(barcodeIn))
                        {
                            /********************************************************************
                             * procedo per UDC in ingresso:
                             * - Deve essere in una locazione WIP corretta (es: sterratura LS -- )
                             * - Deve avere una sola associazione UDC IN - UDC OUT
                             * 
                             ********************************************************************/

                            // controllo IdxPosizione dell'UDC e confronto con posizione in web.config x  posizione richiesta (es:fusi pre sterratura/taglio, trattati pre FINITI, ...)
                            int IdxPosizione = DataProxy.obj.taCartellini.stp_getByUdc(barcodeIn)[0].IdxPosizione;
                            if (IdxPosizione == idxPosizioneIn)
                            {

                                // calcolo nuovo particolare
                                string currParticolare = DataProxy.obj.taCartellini.stp_getByUdc(barcodeIn)[0].Particolare;

                                int idxCellaCurr = 0;
                                try
                                {
                                    idxCellaCurr = MagClass.magazzino.taPosUdcCorr.getByUDC(barcodeIn)[0].IdxCella;
                                }
                                catch
                                { }
                                string codBloccoCurr = "";
                                int idxBlocco = 0;
                                try
                                {
                                    idxBlocco = MagClass.magazzino.taCelle.getByIdxCella(idxCellaCurr)[0].IdxBlocco;
                                    codBloccoCurr = MagClass.magazzino.taBlocchi.getByIdx(idxBlocco)[0].CodBlocco;
                                }
                                catch
                                { }

                                // controllo sia in WIP terra sterratura
                                if (codBloccoCurr == codBloccoIn)
                                {
                                    // controllo abbia 1 sola associazione fusi/sterrato COME CHILD
                                    DS_Applicazione.RelazUDCDataTable tabRel = DataProxy.obj.taRelazUDC.stp_getChild(barcodeIn);
                                    if (tabRel.Rows.Count > 1)
                                    {
                                        divSblocca.Visible = false;
                                        Postazione.messaggiText += " - Attenzione, UDC in ingresso associato a più di un UDC in uscita!";
                                        Postazione.CssClass = "stileComandoKo";
                                    }
                                    else if (tabRel.Rows.Count == 1)
                                    {
                                        // controllo che l'UDC EVENTUALMENTE in relazione NON sia in idxPosizVeto
                                        string udcChild = tabRel[0].UDC_child;
                                        DS_magazzino.ElencoCartelliniRow rigaCart = MagClass.magazzino.taCartellini.getByUdc(udcChild)[0];
                                        if (rigaCart.IdxPosizione != idxPosizioneChildOk)
                                        {
                                            divSblocca.Visible = false;
                                            Postazione.messaggiText += string.Format(" - Attenzione, UDC in ingresso associato ad un UDC già stampato! ({0} si trova in posizione {1})", rigaCart.UDC, rigaCart.IdxPosizione);
                                            Postazione.CssClass = "stileComandoKo";
                                        }
                                        else
                                        {
                                            // tutto ok!
                                            currUDC = barcodeIn;
                                            Postazione.CssClass = "stileComandoOk";
                                            divSblocca.Visible = true;
                                        }
                                    }
                                    else
                                    {
                                        currUDC = barcodeIn;
                                        Postazione.CssClass = "stileComandoOk";
                                        divSblocca.Visible = true;
                                    }
                                }
                                else
                                {
                                    divSblocca.Visible = false;
                                    Postazione.messaggiText += string.Format(" - Attenzione, UDC NON RISULTA caricato su linea corretta ({0})!", codBloccoIn);
                                    Postazione.CssClass = "stileComandoKo";
                                }
                            }
                            else
                            {
                                divSblocca.Visible = false;
                                Postazione.messaggiText += string.Format(" - Attenzione, UDC NON in posizione corretta per sblocco ({0})!", idxPosizioneIn);
                                Postazione.CssClass = "stileComandoKo";
                            }
                        }

                        // update 
                        doUpdate();
                        break;
                    default:
                        Postazione.messaggiText += " - codice <b>non riconosciuto</b>!";
                        Postazione.CssClass = "stileComandoND";
                        divSblocca.Visible = false;
                        break;
                }
                barcodeIn = "";
            }
            else
            {
                Postazione.messaggiText = traduci("AttesaBCode");
                Postazione.CssClass = "stileAttesa";
            }
            txtBarcode.Focus();
        }

        /// <summary>
        /// aggiorna tabella + focus a barcode
        /// </summary>
        public void doUpdate()
        {
            idxCella = Postazione.currIdxCella;
            grView.DataBind();
            txtBarcode.Focus();
            // raise dell'evento
            if (eh_reqUpdate != null)
            {
                eh_reqUpdate(this, new EventArgs());
            }
        }
        /// <summary>
        /// effettua reset dati
        /// </summary>
        public void doResetData()
        {
            // resetto i dati QtaTot e particolare...
            currParticolare = "";
            doChecks();
        }

        protected void grView_PageIndexChanged(object sender, EventArgs e)
        {
            // fix dell'ODS
            checkFixOds();
        }
        protected void grView_Sorted(object sender, EventArgs e)
        {
            // fix dell'ODS
            checkFixOds();
        }
        /// <summary>
        /// aggiorno ods al binding..
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void ods_DataBinding(object sender, EventArgs e)
        {
            // fix dell'ODS
            checkFixOds();
        }
        /// <summary>
        /// verifica se attivo filtro company e imposta ods di conseguenza...
        /// </summary>
        private void checkFixOds()
        {
        }


        /// <summary>
        /// sblocca UDC
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void SbloccaUDC_Click(object sender, EventArgs e)
        {
            // va cancellata la sua relazione con UDC OUT e va spostato in locazione Finiti Terra
            DataProxy.obj.taCartellini.sbloccaDaPost(eventoUDC, idxPosizioneIn, currUDC, "", MagClass.magazzino.CodSoggCurrUser);
            // resetto selezione
            divSblocca.Visible = false;
            currUDC = "";
            currParticolare = "";
            doUpdate();
        }
    }
}