using System;
using System.Configuration;
using System.IO;
using System.Web;





namespace ETS_Data
{
    public class utils
    {
        protected AppSettingsReader configAppSetReader;

        #region area table adapters

        public DS_AnagraficaTableAdapters.UtentiTableAdapter taUtenti;
        public DS_AnagraficaTableAdapters.DirittiTableAdapter taDiritti;

        public DS_utilsTableAdapters.v_selFontiTableAdapter taSelFonti;
        public DS_utilsTableAdapters.v_selCommesseTableAdapter taSelCommesse;
        public DS_utilsTableAdapters.v_selFasiTableAdapter taSelFasi;
        public DS_utilsTableAdapters.v_selAutoriTableAdapter taSelAutori;
        public DS_utilsTableAdapters.v_tbDocs_selFontiTableAdapter taTDSelFonti;
        public DS_utilsTableAdapters.v_tbDocs_selCommesseTableAdapter taTDSelCommesse;
        public DS_utilsTableAdapters.v_tbDocs_selFasiTableAdapter taTDSelFasi;
        public DS_utilsTableAdapters.v_tbDocs_selOggettoTableAdapter taTDSelOggetti;
        public DS_utilsTableAdapters.v_tbDocs_selRedattoreTableAdapter taTDSelRedattore;
        public DS_utilsTableAdapters.stp_calcolaProtocolloTableAdapter taCalcProto;
        public DS_utilsTableAdapters.v_selEmailFornitoriTableAdapter taEmailForn;
        public DS_utilsTableAdapters.AnagSuggestTagsTableAdapter taAST;
        public DS_utilsTableAdapters.v_selFonti_explTableAdapter taVSFE;

        public DS_WebScipTableAdapters.tbDocumentiTableAdapter taDoc;
        public DS_WebScipTableAdapters.Tags2DocTableAdapter taTags2Doc;
        public DS_WebScipTableAdapters.tbMetaDataSetTableAdapter taTMD;
        public DS_WebScipTableAdapters.stp_userLoginRefreshDbTableAdapter taDBRefresh;


        /// <summary>
        /// init dei table adapters
        /// </summary>
        protected void initTA()
        {
            taUtenti = new DS_AnagraficaTableAdapters.UtentiTableAdapter();
            taDiritti = new DS_AnagraficaTableAdapters.DirittiTableAdapter();
            taSelFonti = new DS_utilsTableAdapters.v_selFontiTableAdapter();
            taSelCommesse = new DS_utilsTableAdapters.v_selCommesseTableAdapter();
            taSelFasi = new DS_utilsTableAdapters.v_selFasiTableAdapter();
            taSelAutori = new DS_utilsTableAdapters.v_selAutoriTableAdapter();
            taTDSelFonti = new DS_utilsTableAdapters.v_tbDocs_selFontiTableAdapter();
            taTDSelCommesse = new DS_utilsTableAdapters.v_tbDocs_selCommesseTableAdapter();
            taTDSelFasi = new DS_utilsTableAdapters.v_tbDocs_selFasiTableAdapter();
            taTDSelOggetti = new DS_utilsTableAdapters.v_tbDocs_selOggettoTableAdapter();
            taTDSelRedattore = new DS_utilsTableAdapters.v_tbDocs_selRedattoreTableAdapter();
            taCalcProto = new DS_utilsTableAdapters.stp_calcolaProtocolloTableAdapter();
            taEmailForn = new DS_utilsTableAdapters.v_selEmailFornitoriTableAdapter();
            taAST = new DS_utilsTableAdapters.AnagSuggestTagsTableAdapter();
            taVSFE = new DS_utilsTableAdapters.v_selFonti_explTableAdapter();
            taDoc = new DS_WebScipTableAdapters.tbDocumentiTableAdapter();
            taTags2Doc = new DS_WebScipTableAdapters.Tags2DocTableAdapter();
            taTMD = new DS_WebScipTableAdapters.tbMetaDataSetTableAdapter();
            taDBRefresh = new DS_WebScipTableAdapters.stp_userLoginRefreshDbTableAdapter();
        }
        /// <summary>
        /// effettua setup dei connection strings da web.config delal singola applicazione
        /// </summary>
        protected virtual void setupConnectionStringBase()
        {
            string connStringETS_WS = (string)configAppSetReader.GetValue("ETS_WSConnectionString", typeof(string));
            string connStringETS_WAnagrafica = (string)configAppSetReader.GetValue("ETS_AnagraficaConnectionString", typeof(string));
            // connections del db
            taUtenti.Connection.ConnectionString = connStringETS_WAnagrafica;
            taDiritti.Connection.ConnectionString = connStringETS_WAnagrafica;

            taSelFonti.Connection.ConnectionString = connStringETS_WS;
            taSelCommesse.Connection.ConnectionString = connStringETS_WS;
            taSelFasi.Connection.ConnectionString = connStringETS_WS;
            taSelAutori.Connection.ConnectionString = connStringETS_WS;
            taTDSelFonti.Connection.ConnectionString = connStringETS_WS;
            taTDSelCommesse.Connection.ConnectionString = connStringETS_WS;
            taTDSelFasi.Connection.ConnectionString = connStringETS_WS;
            taTDSelOggetti.Connection.ConnectionString = connStringETS_WS;
            taTDSelRedattore.Connection.ConnectionString = connStringETS_WS;
            taCalcProto.Connection.ConnectionString = connStringETS_WS;
            taEmailForn.Connection.ConnectionString = connStringETS_WS;
            taAST.Connection.ConnectionString = connStringETS_WS;
            taVSFE.Connection.ConnectionString = connStringETS_WS;
            taDoc.Connection.ConnectionString = connStringETS_WS;
            taTags2Doc.Connection.ConnectionString = connStringETS_WS;
            taTMD.Connection.ConnectionString = connStringETS_WS;
            taDBRefresh.Connection.ConnectionString = connStringETS_WS;
        }

        #endregion

        #region Inizializzazione

        protected utils()
        {
            configAppSetReader = new AppSettingsReader();
            initTA();
            setupConnectionStringBase();
        }

        /// <summary>
        /// oggetto static per fare chiamate sul magazzino
        /// </summary>
        public static utils obj = new utils();

        #endregion

        #region area user (wrapper su user_std)

        /// <summary>
        /// WRAPPER utente correntemente connesso (Formato dominio\username)
        /// </summary>
        public string currUserAD
        {
            get
            {
                return user_std.UtSn.currUserAD;
            }
        }
        /// <summary>
        /// WRAPPER utente correntemente connesso per utilizzo FileSystem (Formato dominio.username)
        /// </summary>
        public string currUser_FS
        {
            get
            {
                return user_std.UtSn.currUser_FS;
            }
        }
        /// <summary>
        /// WRAPPER utente correntemente connesso (Formato Cognome nome)
        /// </summary>
        public string currUserCognomeNome
        {
            get
            {
                return user_std.UtSn.currUserCognomeNome;
            }
        }
        /// <summary>
        /// WRAPPER utente correntemente connesso (Formato Nome Cognome)
        /// </summary>
        public string currUserNomeCognome
        {
            get
            {
                return user_std.UtSn.currUserNomeCognome;
            }
        }
        /// <summary>
        /// WRAPPER EMAIL utente correntemente connesso
        /// </summary>
        public string currUserEmail
        {
            get
            {
                return user_std.UtSn.currUserEmail;
            }
        }
        /// <summary>
        /// WRAPPER UserId (AD) utente correntemente connesso
        /// </summary>
        public string currUserId
        {
            get
            {
                return user_std.UtSn.currUserId;
            }
        }
        /// <summary>
        /// WRAPPER calcola se l'utente abbia il diritto x la funzione indicata
        /// </summary>
        /// <param name="utenteAD">username formato AD</param>
        /// <param name="codModulo">codice modulo</param>
        /// <param name="codFunzione">codice funzione</param>
        /// <returns></returns>
        public bool userHasRight(string utenteAD, string codModulo, string codFunzione)
        {
            return user_std.UtSn.userHasRight(utenteAD, codModulo, codFunzione);
        }

        #endregion

        #region area Session

        /// <summary>
        /// carica dalla sessione un dato di tipo object generico
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public object objSessionObj(string nomeVar)
        {
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                return HttpContext.Current.Session[nomeVar];
            }
            else
            {
                return "";
            }
        }

        /// <summary>
        /// carica dalla sessione un dato di tipo boolean (se vuoto false)
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public bool BoolSessionObj(string nomeVar)
        {
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                return (bool)HttpContext.Current.Session[nomeVar];
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// carica dalla sessione un dato di tipo string
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public string StringSessionObj(string nomeVar)
        {
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                return HttpContext.Current.Session[nomeVar].ToString();
            }
            else
            {
                return "";
            }
        }

        /// <summary>
        /// carica dalla sessione un dato di tipo long
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public long LongSessionObj(string nomeVar)
        {
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                return (long)Convert.ToInt32(HttpContext.Current.Session[nomeVar].ToString());
            }
            else
            {
                return 0;
            }
        }

        /// <summary>
        /// carica dalla sessione un dato di tipo int
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public int IntSessionObj(string nomeVar)
        {
            if (HttpContext.Current.Session[nomeVar] != null)
            {
                return (int)Convert.ToInt32(HttpContext.Current.Session[nomeVar].ToString());
            }
            else
            {
                return -1;
            }
        }

        /// <summary>
        /// inserisce in session un valore
        /// </summary>
        /// <param name="nome"></param>
        /// <param name="valore"></param>
        public bool setSessionVal(string nome, object valore)
        {
            bool _done = false;
            try
            {
                HttpContext.Current.Session[nome] = valore;
                _done = true;
            }
            catch
            { }
            return _done;
        }

        /// <summary>
        /// svuota una variabile dalla session
        /// </summary>
        /// <param name="nome"></param>
        public bool emptySessionVal(string nome)
        {
            bool _done = false;
            try
            {
                HttpContext.Current.Session.Remove(nome);
                _done = true;
            }
            catch
            { }
            return _done;
        }
        /// <summary>
        /// restituisce true se è presente in session l'oggetto richiesto
        /// </summary>
        /// <param name="nomeVar"></param>
        /// <returns></returns>
        public bool isInSessionObject(string nomeVar)
        {
            bool answ = false;
            bool stringAnsw = false;
            // cerco di fare cast a stringa...
            try
            {
                stringAnsw = (string)HttpContext.Current.Session[nomeVar].ToString() != "";
            }
            catch
            { }
            // infine condizione doppia...
            try
            {
                answ = (HttpContext.Current.Session[nomeVar] != null && stringAnsw);
            }
            catch
            { }
            return answ;
        }

        #endregion

        #region gestione file config

        /// <summary>
        /// legge dalla config un valore bool
        /// </summary>
        /// <param name="nomeParam"></param>
        /// <returns></returns>
        public bool confReadBool(string nomeParam)
        {
            bool answ = false;
            try
            {
                answ = (bool)configAppSetReader.GetValue(nomeParam, typeof(bool));
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// legge dalla config un valore string
        /// </summary>
        /// <param name="nomeParam"></param>
        /// <returns></returns>
        public string confReadString(string nomeParam)
        {
            string answ = "";
            try
            {
                answ = (string)configAppSetReader.GetValue(nomeParam, typeof(string));
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// legge dalla config un valore int
        /// </summary>
        /// <param name="nomeParam"></param>
        /// <returns></returns>
        public int confReadInt(string nomeParam)
        {
            int answ = -1;
            try
            {
                answ = (int)configAppSetReader.GetValue(nomeParam, typeof(int));
            }
            catch
            { }
            return answ;
        }

        #endregion

        #region area varie

        /// <summary>
        /// ripulisce la stringa da eventuali caratteri non ammessi quali
        ///  [ .,;\/]
        ///  e OPZIONALMENTE toglie " " (spazi) sostituendoli con "_" (underscore)
        /// </summary>
        /// <param name="originalName">stringa originale</param>
        /// <param name="keepSpaces">definisce se mantenere (true) o togliere (false) gli spazi (eventualmente sostituendo con underscore "_")</param>
        /// <returns></returns>
        public static string cleanPathName(string originalName, bool keepSpaces)
        {
            string answ = originalName.Trim().Replace("&", "e").Replace(".", "").Replace(",", "").Replace(";", "").Replace(":", "").Replace("/", "-").Replace(@"\", "-").Replace(@"'", "_").Replace("\"", "_").Replace("#", "_").Replace("?", "_").Replace("*", "_").Replace(" ", "_").Replace("__", "_").Replace("__", "_").Replace("__", "_").Replace("__", "_"); ;
            if (keepSpaces)
            {
                answ = originalName.Trim().Replace("&", "e").Replace(".", "").Replace(",", "").Replace(";", "").Replace(":", "").Replace("/", "-").Replace(@"\", "-").Replace(@"'", "_").Replace("\"", "_").Replace("#", "_").Replace("?", "_").Replace("*", "_").Replace("  ", " ").Replace("  ", " ").Replace("  ", " ").Replace("  ", " ").Replace("__", "_").Replace("__", "_").Replace("__", "_").Replace("__", "_");
            }
            return answ;
        }
        /// <summary>
        /// ripulisce la stringa da eventuali caratteri non ammessi quali
        ///  [ .,;\/]
        ///  e toglie " " (spazi) sostituendoli con "_" (underscore)
        /// </summary>
        /// <param name="originalName">stringa originale</param>
        /// <returns></returns>
        public static string cleanPathName(string originalName)
        {
            return cleanPathName(originalName, false);
        }
        /// <summary>
        /// restituisce, in caso di null o stringa vuota, il carattere "*"
        /// </summary>
        /// <param name="original"></param>
        /// <returns></returns>
        public static string emptyToStar(string original)
        {
            string answ = original;
            if ((original == null) || (original == ""))
            {
                answ = "*";
            }
            return answ;
        }
        /// <summary>
        /// Effettua shring di una stringa ricudendola in lunghezza (tiene inizio/fine + eventuale ".." centrale se lungh superiore a indicata)
        /// </summary>
        /// <param name="originalString">stringa originale</param>
        /// <param name="maxLenght">lungh max desiderata</param>
        /// <returns></returns>
        public static string shrinkString(string originalString, int maxLenght)
        {
            string answ = originalString;
            if (answ.Length > maxLenght)
            {
                string sep = utils.obj.confReadString("separatoreTrim");
                int numChar = (maxLenght - sep.Length) / 2;
                answ = string.Format("{0}{1}{2}", answ.Substring(0, numChar), sep, answ.Substring(answ.Length - (maxLenght - 3 - numChar)));
            }
            return answ;
        }

        public static int pageSizeConf
        {
            get
            {
                return obj.confReadInt("pageSize");
            }
        }
        /// <summary>
        /// dim pagina desiderata
        /// </summary>
        public static int pageSize
        {
            get
            {
                int answ = 0;
                try
                {
                    answ = utils.obj.IntSessionObj("pageSize");
                }
                catch
                { }
                if (answ <= 0)
                {
                    answ = 20;
                }
                return answ;
            }
            set
            {
                utils.obj.setSessionVal("pageSize", value);
            }
        }
        #endregion
    }
    /// <summary>
    /// definisce un intervalo di 2 date
    /// </summary>
    public struct intervalloDate
    {
        /// <summary>
        /// data inizio
        /// </summary>
        public DateTime inizio;
        /// <summary>
        /// data fine
        /// </summary>
        public DateTime fine;
        /// <summary>
        /// indica se sia valido il dato, ovvero inizio e fine > 0 e FINE >= INIZIO
        /// </summary>
        public bool isValid
        {
            get
            {
                bool cond1 = false;
                bool cond2 = false;
                bool cond3 = false;
                try
                {
                    cond1 = inizio > Convert.ToDateTime("01/01/0001");
                }
                catch
                { }
                try
                {
                    cond2 = fine > Convert.ToDateTime("01/01/0001");
                }
                catch
                { }
                try
                {
                    cond3 = (fine.Subtract(inizio).TotalHours > 0);
                }
                catch
                { }
                return (cond1 && cond2 && cond3);
            }
        }
    }
    /// <summary>
    /// classe di funzioni inerenti le date
    /// </summary>
    public class datario
    {
        /// <summary>
        /// inizializzazione empty
        /// </summary>
        public datario()
        {
        }
        /// <summary>
        /// costruisce un oggetto intervallo date
        /// </summary>
        /// <param name="inizio"></param>
        /// <param name="fine"></param>
        /// <returns></returns>
        public intervalloDate setIntervallo(DateTime inizio, DateTime fine)
        {
            intervalloDate periodo = new intervalloDate();
            periodo.inizio = inizio;
            periodo.fine = fine;
            return periodo;
        }
        /// <summary>
        /// effettua l'operazione di intersezione tra 2 intervali di date restituendo ulteriore intervallo: NB se sono intervali disgiunti restituisce 9/9/9999 x inizio e fine
        /// </summary>
        /// <param name="interv1"></param>
        /// <param name="interv2"></param>
        /// <returns></returns>
        public intervalloDate intersecaIntervalli(intervalloDate interv1, intervalloDate interv2)
        {
            intervalloDate interv3;
            // verifico non siano disgiunti...
            if (interv1.fine < interv2.inizio || interv2.fine < interv1.inizio)
            {
                interv3.inizio = Convert.ToDateTime("9/9/9999");
                interv3.fine = Convert.ToDateTime("9/9/9999");
            }
            else
            {
                interv3 = interv1;
                if (interv2.inizio > interv1.inizio)
                {
                    interv3.inizio = interv2.inizio;
                }
                if (interv2.fine < interv1.fine)
                {
                    interv3.fine = interv2.fine;
                }
            }
            return interv3;
        }
        /// <summary>
        /// oggetto mese precedente alla dataLilmite
        /// </summary>
        /// <param name="dataLimite"></param>
        public intervalloDate mesePrecedente(DateTime dataLimite)
        {
            intervalloDate interv = new intervalloDate();
            interv.inizio = dataLimite.AddMonths(-1).AddDays(-(dataLimite.Day - 1)).Subtract(dataLimite.TimeOfDay);
            interv.fine = dataLimite.AddDays(-(dataLimite.Day - 1)).Subtract(dataLimite.TimeOfDay);
            return interv;
        }
        /// <summary>
        /// oggetto mese corrente fino alla dataLilmite
        /// </summary>
        /// <param name="dataLimite"></param>
        public intervalloDate meseCorrente(DateTime dataLimite)
        {
            intervalloDate interv = new intervalloDate();
            interv.inizio = dataLimite.AddDays(-(dataLimite.Day - 1)).Subtract(dataLimite.TimeOfDay);
            interv.fine = dataLimite.Subtract(dataLimite.TimeOfDay);
            return interv;
        }
        /// <summary>
        /// confronta le date e restituisce true se le date sono nello stesso mese
        /// </summary>
        /// <param name="data1"></param>
        /// <param name="data2"></param>
        /// <returns></returns>
        public bool stessoMese(DateTime data1, DateTime data2)
        {
            bool stessoMese = false;
            if ((data1.Year == data2.Year) && (data1.Month == data2.Month))
            {
                stessoMese = true;
            }
            return stessoMese;
        }
        /// <summary>
        /// restituisce l'intervallo del giorno completo che comprende la data indicata
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public intervalloDate giornata(DateTime data)
        {
            intervalloDate interv = new intervalloDate();
            interv.inizio = data.Subtract(data.TimeOfDay);
            interv.fine = interv.inizio.AddDays(1);
            return interv;
        }
        /// <summary>
        /// restituisce l'intervallo di N giorni fino alla data indicata
        /// </summary>
        /// <param name="data"></param>
        /// <param name="numGiorniPrima"></param>
        /// <returns></returns>
        public intervalloDate ultimiGiorni(DateTime data, int numGiorniPrima)
        {
            intervalloDate interv = new intervalloDate();
            interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
            interv.inizio = interv.fine.AddDays(-numGiorniPrima);
            return interv;
        }
        /// <summary>
        /// restituisce l'intervallo della settimana corrente per la data indicata
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public intervalloDate questaSett(DateTime data)
        {
            intervalloDate interv = new intervalloDate();
            interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
            DayOfWeek giorno = data.DayOfWeek;
            int numGG = 0;
            switch (giorno)
            {
                case DayOfWeek.Monday:
                    numGG = 1;
                    break;
                case DayOfWeek.Tuesday:
                    numGG = 2;
                    break;
                case DayOfWeek.Wednesday:
                    numGG = 3;
                    break;
                case DayOfWeek.Thursday:
                    numGG = 4;
                    break;
                case DayOfWeek.Friday:
                    numGG = 5;
                    break;
                case DayOfWeek.Saturday:
                    numGG = 6;
                    break;
                case DayOfWeek.Sunday:
                    numGG = 7;
                    break;
                default:
                    break;
            }
            interv.inizio = interv.fine.AddDays(-numGG);
            return interv;
        }
        /// <summary>
        /// restituisce l'intervallo del mese corrente per la data indicata (dal giorno 1 all'indomani delal data indicata)
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public intervalloDate questoMese(DateTime data)
        {
            intervalloDate interv = new intervalloDate();
            interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
            interv.inizio = interv.fine.AddDays(-data.Day);
            return interv;
        }
        /// <summary>
        /// restituisce l'intervallo del mese che comprende la data indicata (dal primo all'ultimo giorno)
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public intervalloDate estremiMese(DateTime data)
        {
            intervalloDate interv = new intervalloDate();
            interv.inizio = data.AddDays(-(data.Day - 1)).Subtract(data.TimeOfDay);
            interv.fine = interv.inizio.AddMonths(1);
            return interv;
        }
        /// <summary>
        /// restituisce l'intervallo dell'anno corrente per la data indicata
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public intervalloDate estremiAnno(DateTime data)
        {
            intervalloDate interv = new intervalloDate();
            interv.inizio = data.AddDays(-(data.Day - 1)).AddMonths(-(data.Month - 1)).Subtract(data.TimeOfDay);
            interv.fine = interv.inizio.AddMonths(12);
            return interv;
        }
        /// <summary>
        /// oggetto singleton
        /// </summary>
        public static datario mngr = new datario();
    }
}