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

namespace GMW.WebUserControls
{
    public partial class mod_trattamenti : GMW_data.UserControlBCodeMan
    {
        /// <summary>
        /// Stato UDC in ingresso alternativo accettato
        /// </summary>
        protected string statoUDC_preAlt = "FusSter";
        /// <summary>
        /// Imposta variabili specifiche classe
        /// </summary>
        public override void setupVariabili()
        {
            flusso = "TT";
            statoUDC = "Tratt";
            eventoUDC = "UDC_TRATT";
            eventoUDC_qta = "UDC_QTY";
            statoUDC_pre = "Sterr";
            attrNumTra = "NT";
            flusso_TR = "TR";
            tipoUdcLinea = "Trattato";
            IdxPosizioneIn = memLayer.ML.cdvi("IdxPosizioneSterrati");
            IdxPosizioneOut = memLayer.ML.cdvi("IdxPosizioneTrattati");
            tipoCartCurr = tipoCartellino.cartTratt;
        }

        /// <summary>
        /// caricamento pagina
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public override void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                resetTrattamenti();
                resetUDC();
            }
            base.Page_Load(sender, e);
        }
        /// <summary>
        /// controlla particolare selezionato
        /// </summary>
        public override void checkParticolare()
        {
            if (currParticolare != "")
            {
                lblParticolareAttivo.Text = string.Format("Particolare selezionato <b>{0}</b>", currParticolare);
                // aggiungo descrizione del particolare
                string descr = "";
                string disegno = "";
                getDescrDisegnoParticolare(currParticolare, ref descr, ref disegno);
                lblDescrAttivo.Text = descr;
                lblDisegno.Text = disegno;
            }
            else
            {
                lblParticolareAttivo.Text = "...";
                lblDescrAttivo.Text = "";
                lblDisegno.Text = "";
            }
        }
        /// <summary>
        /// sistemo labels oggetti
        /// </summary>
        public override void traduciObj()
        {
            base.traduciObj();
            // labels
            lblAnnoTratt.Text = traduci("lblAnnoTratt");
            lblNumTratt.Text = traduci("lblNumTratt");
            //txtBox
            txtQta.Text = memLayer.ML.cdv("QtaImballoTratt");
            txtAnno.Text = DateTime.Now.Year.ToString();
            // buttons
            btnEmptyNote.Text = traduci("btnEmptyNote");
        }
        /// <summary>
        /// valore barcode
        /// </summary>
        public override string barcodeIn
        {
            get
            {
                return txtBarcode.Text.Trim();
            }
            set
            {
                txtBarcode.Text = value;
            }
        }
        /// <summary>
        /// qta pezzi TOTALE
        /// </summary>
        public override int qta
        {
            get
            {
                int qta = 0;
                try
                {
                    qta = Convert.ToInt32(txtQta.Text.Trim());
                }
                catch
                { }
                return qta;
            }
            set
            {
                txtQta.Text = value.ToString();
            }
        }
        /// <summary>
        /// controlla se ci sia un barcode
        /// </summary>
        public override void checkBarcode()
        {
            if (barcodeIn != "")
            {
                Postazione.messaggiText = string.Format("Barcode digitato: {0}", barcodeIn);
                Postazione.warningText = "";
                switch (MagClass.tipoBCode_L3(barcodeIn))
                {
                    case tipoCodiceBarcode.Particolare:
                        // 2014.02.13: tolto perché NON si vuole particolare OUT diverso da IN
                        break;
                    case tipoCodiceBarcode.UDC:
                        /* controllo UDC:
                         * 
                         * - deve esistere
                         * - stato corretto
                         * - posizione corretta (e NON consumati, 2014.05.19)
                         */

                        // procedo solo se UDC esistente
                        if (MagClass.magazzino.checkUDC(barcodeIn))
                        {
                            // controllo se NON ci siano NC "pending"
                            if (MagClass.magazzino.checkUDC_NC(barcodeIn) != checkUdcNc.HasNc)
                            {
                                bool posizOk = false;
                                if (memLayer.ML.confReadString("codPartTrattDeroga").IndexOf(string.Format("#{0}#", DataProxy.obj.taCartellini.stp_getByUdc(barcodeIn)[0].Particolare)) >= 0)
                                {
                                    // controllo se il particolare è in quelli che accettano UDC già consumati
                                    posizOk = (Math.Abs(MagClass.magazzino.IdxPosizioneUdc(barcodeIn)) == IdxPosizioneIn);
                                }
                                else
                                {
                                    posizOk = MagClass.magazzino.IdxPosizioneUdc(barcodeIn) == IdxPosizioneIn;
                                }
                                // posizione corretta
                                if (posizOk)
                                {
                                    if (MagClass.magazzino.CodStatoUdc(barcodeIn) == statoUDC_pre || MagClass.magazzino.CodStatoUdc(barcodeIn) == statoUDC_preAlt)
                                    {
                                        // 2014.02.14 non permetto + di 1 UDC: svuoto elenco!
                                        elencoUDC.Clear();
                                        // se è ok aggiungo in elenco UDC e mostro update
                                        checkUdc4elenco(barcodeIn);
                                        // carico nelle note dell'UDC NUOVO
                                        txtNote.Text = MagClass.magazzino.taCartellini.getByUdc(barcodeIn)[0].Note;
                                        // seleziono anche particolare corrente
                                        currParticolare = DataProxy.obj.taCartellini.stp_getByUdc(barcodeIn)[0].Particolare;
                                        qta = Convert.ToInt32(DataProxy.obj.taCartellini.stp_getByUdc(barcodeIn)[0].Qta);
                                        checkStampa();
                                        // 2014.02.14: non imposto + ultima qta perché ho preso da UDC sorgente
                                        //fixNumPezzi();
                                        Postazione.CssClass = "stileComandoOk";
                                    }
                                    else
                                    {
                                        Postazione.messaggiText += " - UDC in stato non corretto!";
                                        Postazione.CssClass = "stileComandoKO";
                                    }
                                }
                                else
                                {
                                    Postazione.messaggiText += " - UDC in posizione non corretta!";
                                    Postazione.CssClass = "stileComandoKO";
                                }

                                // controllo SE PER CASO ci fosse NC e ci sia stata deroga, cambio MSG...
                                if (MagClass.magazzino.checkUDC_NC(barcodeIn) == checkUdcNc.ChkDis_HasNc)
                                {
                                    Postazione.CssClass = "stileComandoKo";
                                    Postazione.messaggiText += string.Format("<br />{0}", traduci("ERR-NC-001"));
                                    // recupero l'NC associata...
                                    Postazione.warningText += string.Format("<br />{0}", MagClass.magazzino.getDescrNc2Udc(barcodeIn));
                                }
                            }
                            else
                            {
                                Postazione.CssClass = "stileComandoKo";
                                Postazione.messaggiText += string.Format("<br />{0}", traduci("ERR-NC-001"));
                                // recupero l'NC associata...
                                Postazione.warningText += string.Format("<br />{0}", MagClass.magazzino.getDescrNc2Udc(barcodeIn));
                            }
                        }
                        break;
                    case tipoCodiceBarcode.Operatore:
                        // calcolo matricola utente
                        int MatrUtente = -1;
                        string preCodSogg = memLayer.ML.AppConf["prefCodSogg"];
                        if (barcodeIn.StartsWith(preCodSogg))
                        {
                            MatrUtente = DataProxy.obj.taTrascSogg.getByKey(barcodeIn, 0)[0].CodMatricola;
                        }
                        else
                        {
                            MatrUtente = Convert.ToInt32(barcodeIn);
                        }
                        if (MatrUtente >= 0)
                        {
                            // salvo in sessione operatore con AUTH
                            OpAuth.startOpAuth(MatrUtente);
                            // mostro che ho autorizzato...
                            Postazione.messaggiText += " - " + traduci("userAuthRec");
                            Postazione.CssClass = "stileComandoOk";
                            currParticolare = "";
                            qta = 0;
                            Response.Redirect(user_std.pagCorrente);
                        }
                        else
                        {
                            Postazione.messaggiText += " - codice <b>non riconosciuto</b>!";
                            Postazione.CssClass = "stileComandoND";
                        }
                        break;
                    default:
                        // cerco se sia "0" = reset utente...
                        if (barcodeIn == memLayer.ML.CRS("resetCodSogg"))
                        {
                            // salvo in sessione operatore con AUTH
                            OpAuth.stopAuth();
                            // mostro che ho autorizzato...
                            Postazione.messaggiText += traduci("userAuthRem");
                            Postazione.CssClass = "stileComandoOk";
                            Response.Redirect(user_std.pagCorrente);
                        }
                        Postazione.messaggiText += " - codice <b>non riconosciuto</b>!";
                        Postazione.CssClass = "stileComandoND";
                        break;
                }
                barcodeIn = "";
            }
            //grView.DataBind();
            txtBarcode.Focus();
            // raise dell'evento
            raiseEvent(ucEvType.ReqUpdateParent);
        }
        /// <summary>
        /// aggiorna tabella + focus a barcode
        /// </summary>
        public override void doUpdate()
        {
            base.doUpdate();
            txtBarcode.Focus();
            // raise dell'evento
            raiseEvent(ucEvType.ReqUpdateParent);
        }
        /// <summary>
        /// controllo l'abilitazione alla stampa UDC:
        /// - particolare ok
        /// - qta > 0
        /// - almeno 1 trattamento
        /// altrimenti disabilito btn stampa
        /// </summary>
        public override void checkStampa()
        {
            bool stampaOk = false;
            //controllo siano inseriti valori qta
            if (qta > 0)
            {
                // controllo ci siano particolare e ci sia selezionato almeno un UDC e un trattamento
                if (currParticolare != "" && elencoUDC.Count > 0 && elencoTrattamenti.Count > 0)
                {
                    stampaOk = true;
                }
            }
            divNote.Visible = stampaOk;
        }
        /// <summary>
        /// genera i barcode di
        /// - trattamenti
        /// - nuovo x pezzi liquidi
        /// e lancia la relativa stampa
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
        public override void btnStampa_Click(object sender, EventArgs e)
        {
            bool needsRedirect = false;
            string[] stringSeparators = new string[] { "#" };
            // verifico postazione x procedere...
            if (Postazione.printer != "n.d.")
            {
                // verifico auth utente OPPURE se NON sia richiesta...
                if (OpAuth.isAuth || !OpAuth.opAuthReq)
                {
                    // controllo UDC in ingresso, che siano tutti con uguale particolare e DIVERSO da ""
                    string partUdcIn = "";
                    try
                    {
                        // ciclo tutti gli UDC trattati
                        if (elencoUDC.Count > 0)
                        {
                            partUdcIn = checkPartUDC(elencoUDC);
                        }
                    }
                    catch
                    { }
                    if (partUdcIn != "")
                    {
                        // controllo da distinta base coerenza particolare IN/OUT
                        bool partDistintaOk = false;
                        try
                        {
                            if (MagClass.magazzino.taPartIO.GetData(currParticolare, partUdcIn, true)[0].Trovati > 0) partDistintaOk = true;
                        }
                        catch
                        { }
                        if (partDistintaOk)
                        {
                            string newUdcChild = "";
                            string codTratt = "";
                            //bool UdcExists = false;
                            int anno = Convert.ToInt32(txtAnno.Text.Substring(txtAnno.Text.Trim().Length - 2, 2));
                            int qta = memLayer.ML.cdvi("QtaImballoTratt");
                            string noteTrim = txtNote.Text.Trim();
                            try
                            {
                                qta = Convert.ToInt32(txtQta.Text);
                            }
                            catch
                            { }
                            // effettuo controlli che cod_soggetto e cod particolare siano disponibili...
                            string codSogg = "";
                            string particolare = "";
                            try
                            {
                                codSogg = MagClass.magazzino.CodSoggCurrUser;
                                particolare = currParticolare;
                            }
                            catch
                            {
                            }
                            if (codSogg != "" && particolare != "")
                            {
                                // genero cartellino
                                DateTime adesso = DateTime.Now;
                                try
                                {
                                    // creo nuovo UDC trattati
                                    newUdcChild = MagClass.magazzino.creaUdc(flusso, "", currParticolare, "", "", "", "", "", 0, memLayer.ML.cdv("CodImballoTratt"), "U", MagClass.magazzino.CodSoggCurrUser, qta, 0, 0, adesso, 0, statoUDC, IdxPosizioneOut, "IdxPosizioneTrattati", eventoUDC, noteTrim, "", adesso.Year, Request.UserHostName);

                                    if (OpAuth.isAuth)
                                    {
                                        // salvo attributo dell'OpAuth...
                                        MagClass.magazzino.taAtt2UDC.Insert(newUdcChild, memLayer.ML.CRS("attrOpAuth"), OpAuth.currAuth.CodSoggetto, DateTime.Now, codSogg);
                                        // consumo una auth...
                                        OpAuth.currAuth.remAuth--;
                                        if (OpAuth.currAuth.remAuth == 0)
                                        {
                                            OpAuth.stopAuth();
                                            needsRedirect = true;
                                        }
                                    }

                                    // registro creazione nuovo UDC
                                    MagClass.magazzino.taSAO.insertQuery(adesso, codSogg, Postazione.name, Postazione.IP, newUdcChild, particolare, "creaUDC", string.Format("Creato nuovo UDC Trattati, qta: {0} {1}", qta, noteTrim));
                                }
                                catch (Exception exc)
                                {
                                    httpLog(string.Format("Errore creazione UDC Trattato: {0}", exc), tipoLog.EXCEPTION);
                                }
                                // devo gestire associazione e consumo SIA dei trattamenti che degli UDC
                                if (newUdcChild != "")
                                {
                                    // associo UDC da elenco sterrati
                                    foreach (KeyValuePair<string, string> kvp in elencoUDC)
                                    {
                                        // associo i 2 cartellini
                                        MagClass.magazzino.associaUdcParent(newUdcChild, kvp.Key);
                                        // consumo gli UDC indicati (se non già consumati)
                                        consumaUdc(kvp.Key);
                                    }
                                    // creo UDC dei trattamenti termici
                                    foreach (KeyValuePair<string, string> kvp in elencoTrattamenti)
                                    {
                                        // nuova versione codice trattamento (anno-numero)
                                        codTratt = MagClass.magazzino.getCompTrattamenti(txtAnno.Text, kvp.Key);
                                        // inserisco attributo trattamento
                                        MagClass.magazzino.taAtt2UDC.Insert(newUdcChild, attrNumTra, codTratt, DateTime.Now, codSogg);
                                        // cerco se c'è AL
                                        string codAL = string.Format("ALT{0}000000000", anno);
                                        if (MagClass.magazzino.taEA.getByAL(codAL).Rows.Count == 0)
                                        {
                                            // sennò lo creo...
                                            MagClass.magazzino.taEA.Insert(codAL, true, DateTime.Now, "", "", "", "", 0);
                                        }
                                        // cerco se trattamento già salvato...
                                        if (MagClass.magazzino.taET.getByTratt(codTratt).Rows.Count == 0)
                                        {
                                            // salvo NUOVO record in ElencoTrattamenti
                                            MagClass.magazzino.taET.Insert(codTratt, codAL, DateTime.Now, 0, "", null, "", 0, null, "", false);
                                        }
                                    }
                                    // ora stampo il nuovo cartellino!!!
                                    MagClass.magazzino.stampaUdc(newUdcChild, Postazione.printer, tipoCartellino.cartTratt, Request.UserHostName);
                                    // incremento timing...
                                    adesso = DateTime.Now;
                                    adesso = adesso.AddSeconds(2);
                                    // registro stampa nuovo UDC
                                    MagClass.magazzino.taSAO.insertQuery(adesso, codSogg, Postazione.name, Postazione.IP, newUdcChild, particolare, "stampaUDC", "Stampato UDC Trattato");
                                }
                                // resetto
                                doResetData();
                            }
                            else
                            {
                                httpLog(string.Format("TRATTATI, Errore persi utente/particolare, ricarico!"), tipoLog.ERROR);
                                Response.Redirect("~/login.aspx");
                            }
                        }
                        else
                        {
                            httpLog(string.Format("TRATTATI, Errore controllo coerenza particolari da distinta base!"), tipoLog.ERROR);
                            Postazione.messaggiText += "Errore particolari UDC da controllo distinta base";
                            Postazione.CssClass = "stileComandoND";
                        }
                    }
                    else
                    {
                        httpLog(string.Format("TRATTATI, Errore persi utente/particolare, ricarico!"), tipoLog.ERROR);
                        Response.Redirect("~/login.aspx");
                    }
                }
                else
                {
                    Postazione.messaggiText = traduci("noOpAuth");
                    Postazione.CssClass = "stileComandoKo";
                    httpLog(string.Format("Errore manca OpAuth x UDC anime"), tipoLog.ERROR);
                }
            }
            else
            {
                Response.Redirect("~/menu.aspx");
            }
            // raise dell'evento
            raiseEvent(ucEvType.ReqUpdateParent);
            if (needsRedirect)
            {
                Response.Redirect(user_std.pagCorrente);
            }
        }
        /// <summary>
        /// verifica che il vettore di UDC abbia tutto lo stesso particolare e lo restituisce, altrimenti restituisce ""
        /// </summary>
        /// <param name="UDC_P">dictionary di UDC da verificare</param>
        private string checkPartUDC(Dictionary<string, string> UDC_P)
        {
            string answ = "";
            if (UDC_P.Count > 0)
            {
                // imposto il primo particolare...
                IEnumerator enumerator = UDC_P.Keys.GetEnumerator();
                enumerator.MoveNext();
                object first = enumerator.Current;
                answ = MagClass.magazzino.getParticolareByUDC(first.ToString());
                // ciclo
                foreach (KeyValuePair<string, string> udc_p in UDC_P)
                {
                    if (MagClass.magazzino.getParticolareByUDC(udc_p.Key) != answ) answ = ""; // se uno è diverso "azzero"
                }
            }
            return answ;
        }
        /// <summary>
        /// effettua reset dati
        /// </summary>
        public override void doResetData()
        {
            // resetto UDC e trattamenti
            resetTrattamenti();
            resetUDC();
            base.doResetData();
        }
        /// <summary>
        /// elenco dictionary dei trattamenti da associare ad UDC
        /// </summary>
        public Dictionary<string, string> elencoTrattamenti
        {
            get
            {
                try
                {
                    return (Dictionary<string, string>)memLayer.ML.objSessionObj("elencoTrattamenti");
                }
                catch
                {
                    return new Dictionary<string, string>();
                }
            }
            set
            {
                memLayer.ML.setSessionVal("elencoTrattamenti", value, false);
            }
        }
        /// <summary>
        /// aggiungo un oggetto trattamento alla lista..
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnAdd_Click(object sender, EventArgs e)
        {
            if (txtTratt.Text.Trim() != "")
            {
                string valore = txtTratt.Text.Trim();
                Dictionary<string, string> elenco = elencoTrattamenti;
                // controllo il valore non ci sia già...
                if (!elenco.ContainsKey(valore))
                {
                    elenco.Add(valore, "n° " + valore);
                    elencoTrattamenti = elenco;
                }
                txtTratt.Text = "";
                updateListBoxTrattamenti();
            }
            doChecks();
        }
        /// <summary>
        /// aggiorna la listbox
        /// </summary>
        private void updateListBoxTrattamenti()
        {
            lbTrattamenti.DataSource = elencoTrattamenti;
            lbTrattamenti.DataTextField = "Value";
            lbTrattamenti.DataValueField = "Key";
            lbTrattamenti.DataBind();
        }
        /// <summary>
        /// svuota elenco trattamenti
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnSvuota_Click(object sender, EventArgs e)
        {
            resetTrattamenti();
            doChecks();
        }
        /// <summary>
        /// resetta i trattamenti caricati
        /// </summary>
        private void resetTrattamenti()
        {
            Dictionary<string, string> elenco = new Dictionary<string, string>();
            elencoTrattamenti = elenco;
            txtTratt.Text = "";
            updateListBoxTrattamenti();
        }
        /// <summary>
        /// resetta elenco UDC caricati
        /// </summary>
        private void resetUDC()
        {
            Dictionary<string, string> elenco = new Dictionary<string, string>();
            elencoUDC = elenco;
            updateListBoxUDC();
        }

        /// <summary>
        /// elenco dictionary dei trattamenti da associare ad UDC
        /// </summary>
        public Dictionary<string, string> elencoUDC
        {
            get
            {
                try
                {
                    return (Dictionary<string, string>)memLayer.ML.objSessionObj("elencoUDC");
                }
                catch
                {
                    return new Dictionary<string, string>();
                }
            }
            set
            {
                memLayer.ML.setSessionVal("elencoUDC", value, false);
            }
        }
        /// <summary>
        /// svuota elenco trattamenti
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnSvuotaUDC_Click(object sender, EventArgs e)
        {
            resetUDC();
            doChecks();
        }
        /// <summary>
        /// controlla validità UDC x inserire in elenco...
        /// </summary>
        /// <param name="valore"></param>
        private void checkUdc4elenco(string valore)
        {
            if (MagClass.magazzino.checkUDC(valore))
            {
                Dictionary<string, string> elenco = elencoUDC;
                // controllo il valore non ci sia già...
                if (!elenco.ContainsKey(valore))
                {
                    elenco.Add(valore, valore);
                    elencoUDC = elenco;
                }
                updateListBoxUDC();
            }
        }
        /// <summary>
        /// aggiorna la listbox
        /// </summary>
        private void updateListBoxUDC()
        {
            lbUdc.DataSource = elencoUDC;
            lbUdc.DataTextField = "Value";
            lbUdc.DataValueField = "Key";
            lbUdc.DataBind();
        }
        /// <summary>
        /// riverifico stampabilità..
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public override void txtQta_TextChanged(object sender, EventArgs e)
        {
            checkStampa();
        }
    }
}