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

namespace GMW_Term.WebUserControls
{
    public partial class mod_execUdc : System.Web.UI.UserControl
    {

        #region variabili globali controllo

        /// <summary>
        /// codice company/sito in sessione
        /// </summary>
        protected string _CodCS
        {
            get
            {
                return memLayer.ML.StringSessionObj("CodCS");
            }
        }
        /// <summary>
        /// UDC correntemente selezionato
        /// </summary>
        protected string _UDC
        {
            get
            {
                return memLayer.ML.StringSessionObj("UDC_sel");
            }
            set
            {
                memLayer.ML.setSessionVal("UDC_sel", value);
            }
        }
        /// <summary>
        /// CodLista della lsita di prelievo correntemente attiva
        /// </summary>
        protected string _CodLista
        {
            get
            {
                return memLayer.ML.StringSessionObj("CodListaAttiva");
            }
            set
            {
                memLayer.ML.setSessionVal("CodListaAttiva", value);
            }
        }
        /// <summary>
        /// Particolare dell'UDC correntemente selezionato
        /// </summary>
        protected string _PartUdc
        {
            get
            {
                string answ = "";
                try
                {
                    answ = MagClass.magazzino.taDettUDC.getByFullUdc(_UDC, _CodCS)[0].Particolare;
                }
                catch
                { }
                return answ;
            }
        }
        /// <summary>
        /// Indica se l'UDC correntemente selezionato sia disponibile x prelievo
        /// </summary>
        protected bool _UdcDisp
        {
            get
            {
                bool answ = false;
                try
                {
                    answ = (MagClass.magazzino.taRigheListePrelievo.getPrelevateByUdc(_UDC).Rows.Count == 0);
                }
                catch
                { }
                return answ;
            }
        }
        /// <summary>
        /// Indica se la cella DI DESTINAZIONE dell'azione sia da indicare come piena
        /// </summary>
        protected bool _cellaPiena
        {
            get
            {
                return memLayer.ML.BoolSessionObj("cellaPiena");
            }
            set
            {
                memLayer.ML.setSessionVal("cellaPiena", value);
            }
        }
        /// <summary>
        /// Particolare della Lista di Prelievo correntemente attiva
        /// </summary>
        protected string _PartLdP
        {
            get
            {
                string answ = "";
                if (_CodLista != "")
                {
                    try
                    {
                        answ = MagClass.magazzino.taElencoListePrelievo.getByCodLista(_CodLista)[0].Particolare;
                    }
                    catch
                    { }
                }
                return answ;
            }
        }
        /// <summary>
        /// valore della scansione barcode
        /// </summary>
        public string valoreScanUdc
        {
            get
            {
                return memLayer.ML.StringSessionObj("scannedValueUdc");
            }
            set
            {
                memLayer.ML.setSessionVal("scannedValueUdc", value, false);
            }
        }
        /// <summary>
        /// tipologia di edit attivo (in session...)
        /// </summary>
        protected tipoEditUdc editAttivo
        {
            get
            {
                tipoEditUdc answ = tipoEditUdc.nd;
                try
                {
                    answ = (tipoEditUdc)memLayer.ML.objSessionObj("EditAttivo");
                }
                catch
                { }
                return answ;
            }
            set
            {
                memLayer.ML.setSessionVal("EditAttivo", value, false);
            }
        }



        #endregion

        #region setup modulo

        /// <summary>
        /// caricamento pagina
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Page_Load(object sender, EventArgs e)
        {
            mod_btnUdc1.eh_btnPressed += new EventHandler(mod_btnUdc1_eh_btnPressed);
        }
        /// <summary>
        /// premuto un bottone, di conseguenza adatta grafica e/o funzionalità
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void mod_btnUdc1_eh_btnPressed(object sender, EventArgs e)
        {
            switch (editAttivo)
            {
                case tipoEditUdc.nd:
                    break;
                case tipoEditUdc.deliberaFusi:
                    deliberaUdc();
                    break;
                case tipoEditUdc.deliberaWipPost:
                    deliberaUdc();
                    break;
                case tipoEditUdc.deliberaWipPre:
                    deliberaUdc();
                    break;
                case tipoEditUdc.deposito:
                    depositaUdc(_cellaPiena);
                    break;
                case tipoEditUdc.prelievo:
                    break;
                case tipoEditUdc.rettifica:
                    frmView.ChangeMode(FormViewMode.Edit);
                    break;
                case tipoEditUdc.spostamento:
                    spostaUdc(_cellaPiena);
                    break;
                default:
                    break;
            }
        }
        /// <summary>
        /// wrapper traduzione termini
        /// </summary>
        /// <param name="lemma"></param>
        /// <returns></returns>
        public string traduci(string lemma)
        {
            return user_std.UtSn.Traduci(lemma);
        }

        #endregion

        #region metodi operativi interni

        /// <summary>
        /// effattua al delibera dell'UDC indicato
        /// </summary>
        private void deliberaUdc()
        {
            string tipoDelibera = "";
            switch (editAttivo)
            {
                case tipoEditUdc.deliberaFusi:
                    tipoDelibera = "DelibFusi";
                    break;
                case tipoEditUdc.deliberaWipPost:
                    tipoDelibera = "DelibWipPost";
                    break;
                case tipoEditUdc.deliberaWipPre:
                    tipoDelibera = "DelibWipPre";
                    break;
                default:
                    break;
            }
            if (tipoDelibera != "")
            {
                // chiamo stored x fare delibera con state machine
                    string CodEvento = tipoDelibera;
                    try
                    {
                        CodEvento = StateMachine.SM.taATD.getByKey(tipoDelibera)[0].CodEvento;
                    }
                    catch
                    { }
                    StateMachine.SM.deliberaUdc(_UDC, tipoDelibera, CodEvento, Request.UserHostName);
            }
            // resetto buttons
            mod_btnUdc1.doReset();
            // aggiorna dati
            frmView.DataBind();
        }

        /// <summary>
        /// effettua salvataggio, mostra cella updated, eventuale set piena della cella
        /// </summary>
        /// <param name="cellaPiena"></param>
        private void depositaUdc(bool setCellaPiena)
        {
            // controllo UDC sia spostabile (ovvero NON in RLP bloccata)
            if (MagClass.magazzino.checkUDC_mov(_UDC))
            {
                // cerco id della cella...
                int idxCella = MagClass.magazzino.IdxCellaByCodCella(_CodCS, valoreScanUdc);
                // salva le info facendo caricamento
                MagClass.magazzino.spostaUDC(_CodCS, _UDC, idxCella, memLayer.ML.confReadBool("spostaUdcResettaLdp"), Request.UserHostName);
                if (setCellaPiena)
                {
                    MagClass.magazzino.taCelle.stp_celle_updPiena(idxCella, true);
                }
            }
            // resetto buttons
            mod_btnUdc1.doReset();
            // aggiorna dati
            frmView.DataBind();
        }
        /// <summary>
        /// chiama lo spostamento dell'UDC tra la cella attuale e la nuova...
        /// </summary>
        /// <param name="cellaPiena"></param>
        private void spostaUdc(bool setCellaPiena)
        {
            // controllo UDC sia spostabile (ovvero NON in RLP bloccata)
            if (MagClass.magazzino.checkUDC_mov(_UDC))
            {
                // cerco id delle celle...
                int idxCellaFrom = MagClass.magazzino.taDettUDC.getByFullUdc(_UDC, _CodCS)[0].IdxCella;
                int idxCellaTo = MagClass.magazzino.IdxCellaByCodCella(_CodCS, valoreScanUdc);
                // salva le info facendo caricamento
                MagClass.magazzino.spostaUDC(_CodCS, _UDC, idxCellaTo, memLayer.ML.confReadBool("spostaUdcResettaLdp"), Request.UserHostName);
                // dopo aver spostato UDC sistemo eventuali Righe di Prelievo x lo stesso UDC pending...
                MagClass.magazzino.taRigheListePrelievo.stp_RLP_sbloccaNonPrelevate("ND", _UDC); // metto "ND" perché voglio sbloccare tutti gli impieghi di quell'UDC
                // la cella di partenza la indico come disponibile (comunque ho tolto un UDC...)
                MagClass.magazzino.taCelle.stp_celle_updPiena(idxCellaFrom, false);
                if (setCellaPiena)
                {
                    MagClass.magazzino.taCelle.stp_celle_updPiena(idxCellaTo, true);
                }
            }
            // resetto buttons
            mod_btnUdc1.doReset();
            // aggiorna dati
            frmView.DataBind();
        }

        #endregion

        #region gestione interazione (buttons & update...)

        #region area frmView & co

        /// <summary>
        /// eseguo alla chiusura della fase di update
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void frmView_ItemUpdated(object sender, FormViewUpdatedEventArgs e)
        {
            //fixBtnPostUpdateQta();
        }
        /// <summary>
        /// mostra di nuovo buttons post fase di editing
        /// </summary>
        private void fixBtnPostUpdateQta()
        {
            // aggiorno frmView
            frmView.DataBind();
            mod_btnUdc1.doReset();
        }
        /// <summary>
        /// alla chiusura fase di editing
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void frmView_ModeChanged(object sender, EventArgs e)
        {
            // se sono in item mode mostro di nuovo i buttons...
            if (frmView.CurrentMode == FormViewMode.ReadOnly)
            {
                fixBtnPostUpdateQta();
            }
        }
        /// <summary>
        /// evento on update
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void ods_Updating(object sender, ObjectDataSourceMethodEventArgs e)
        {
            // controllo UDC sia modificabile qta
            if (MagClass.magazzino.checkUDC_qty(_UDC))
            {
                decimal qta = Convert.ToDecimal(e.InputParameters["Qta"]);
                // intercetto l'evento e chiamo una stored ad hoc!
                MagClass.magazzino.taCartellini.updateQty(_UDC, MagClass.magazzino.CodSoggCurrUser, "U", "UDC_QTY", qta);
                // aggiorno anche eventuali righe inliste prelievo
                MagClass.magazzino.taRigheListePrelievo.stp_RLP_updateQty(_UDC, qta);
            }
                // annullo update!
            e.Cancel = true;
        }

        #endregion


        #endregion

    }
}
/// <summary>
/// enumerazione tipo di editing effettuato su UDC
/// </summary>
public enum tipoEditUdc
{
    nd,
    deliberaFusi,
    deliberaWipPost,
    deliberaWipPre,
    deposito,
    prelievo,
    rettifica,
    spostamento
}