using System;
using System.Collections.Generic;
using System.Text;
using System.Data.SqlClient;
using De.Lambertz.Portal;
using System.Security.Principal;
using De.Lambertz.Tools;
using System.Data;
using System.Windows.Forms;
using System.Reflection;

namespace De.Lambertz.ODAL
{
    /// <summary>
    /// Alle Userabhängigen Informationen werden hie in einem Singelton zur Verfügung gehalten
    /// </summary>
    public class UserSingelton : ISingelton
    {
        private static UserSingelton me = null;                 //Singelton
        //
        private ODALUser angemeldeterUser = null;               //Userinfo des angemeldeten Users
        private Dictionary<int, ODALBereich> bereiche;          //Alle Bereiche die dem User zugeordnet sind
        private Dictionary<int, ODALBereich> alleBereiche = null; //Alle Bereiche
        private List<ODALBereich> altBereiche = null;
        private StringBuilder bereichsSQL;                      //Vorab aufbereitet Bereiche für SQL-Abfragen
        private Dictionary<int, ODALUser> alleUser;             //Liste aller User
        private Dictionary<int, ODALUser> alleGesperrtenUser;   //Liste aller gesperrten User
        private ODALIni parameter = null;                       //Parameter des angemeldeten Users
        private List<int> vertretungen = null;                  //Usernummern die der Angemeldetet Uservertritt
        private Dictionary<int, List<int>> userFirmen = null;
        //
        //NEUE FREIGABE MECHANISMEN:
        private Dictionary<int, FachBereich> fachBereiche = null; // Alle fachbereiche der neuen Bereichslogik
        private String fachBereichsSQL;                  //Eigene Fachbereiche und FB durch Vertretungen
        //
        static readonly object padlock0 = new object(); //Threadsafe!!
        static readonly object padlock1 = new object(); //Threadsafe!!
        
        private UserSingelton(string userName)
        {
            //Der aktuell angemeldete User 
            angemeldeterUser = new ODALUser();
            this.angemeldeterUser.Login = userName;
            this.alleUser = new Dictionary<int, ODALUser>();
            this.alleGesperrtenUser = new Dictionary<int, ODALUser>();
            // LADEN mit nur einer Connection die später nicht mehr benötigt wird und daher nicht als Member im Singelton gehalten wird!
            if (this.userInfoLaden())
            {
                parameter = new ODALIni();

                this.vertretungen = new List<int>();
                this.vertretungen.Add(angemeldeterUser.UserID);
                this.ladenVertreterKette(angemeldeterUser.UserID);
                
                this.bereiche = new Dictionary<int, ODALBereich>();
                this.bereichsSQL = new StringBuilder();
                this.bereicheLaden();

                //NEUE Bereichslogik
                this.alleFachbereicheLaden();

                this.alleUserFirmenZuordnungenLaden();

                this.userEintragen();
            }
            else
            {
                // BAUSTELLE noch nicht klar was hier passieren soll .. jedenfalls
                // konnte der User nicht gefunden werden!
            }
            //
            ////s.returnConnection();
            // LADEN Ende und abmelden der Connection
        }

        private void alleUserFirmenZuordnungenLaden()
        {
            this.userFirmen = new Dictionary<int, List<int>>();

            using (SqlConnection con = new SqlConnection(DBTools.ConnectionStringODAL()))
            {
                con.Open();
                String sql = "select UserNr, FirmenNr from ODAL.AnwenderFirmen";
                SqlCommand cmd = new SqlCommand(sql, con);
                using(SqlDataReader reader = cmd.ExecuteReader()) 
                {
                    while (reader.Read())
                    {
                        List<int> firmenListe = null;
                        if (userFirmen.ContainsKey(reader.GetInt32(0)))
                        {
                            firmenListe = userFirmen[reader.GetInt32(0)];
                        }
                        else
                        {
                            firmenListe = new List<int>();
                            userFirmen.Add(reader.GetInt32(0), firmenListe);
                        }
                        if (!firmenListe.Contains(reader.GetInt32(1)))
                        {
                            firmenListe.Add(reader.GetInt32(1));
                        }
                    }
                }
            }
        }

        public List<int> GetFirmenListeFürUser(int userNr)
        {
            List<int> result = null;
            if (userFirmen.ContainsKey(userNr))
            {
                result = userFirmen[userNr];
            }
            else
            {
                result = new List<int>();
            }
            return result;
        }

        public Dictionary<int, FachBereich> FachBereiche
        {
            get { return fachBereiche; }
            set { fachBereiche = value; }
        }

        public String FachBereichsSQL
        {
            get { return fachBereichsSQL; }
            set { fachBereichsSQL = value; }
        }

        /// <summary>
        /// Holt die Verbindung zum MSSQL Server
        /// </summary>
        /// <returns></returns>
        private SqlConnection getConnection()
        {
            SqlConnection result = null;
            try
            {
                result = new SqlConnection();
                result.ConnectionString = DBTools.ConnectionStringODAL();
                result.Open();
            }
            catch (Exception)
            {
                result = null;
            }
            return result;
        }

        /// <summary>
        /// Schliesst die Verbindung zum MSSQL Server
        /// </summary>
        /// <returns></returns>
        private void returnConnection(SqlConnection con)
        {
            if (con != null && con.State == ConnectionState.Open)
            {
                con.Close();
            }
        }

        /// <summary>
        /// Laden "aller" Informationen zum User
        /// </summary>
        /// <param name="con"></param>
        private bool userInfoLaden()
        {
            SqlConnection con = getConnection();

            bool result = false;
            StringBuilder sql = new StringBuilder();
            sql.Append("select ANWENDER.USERNR, FIRMENNR, NAME, KOSTENSTELLE, ADMIN, FREIGABE, EMAIL, LOGIN, TELEFON, UNTERSCHRIFT, TE, GESPERRT, ERSTELLER, SZBNamen.anwender from ODAL.ANWENDER left join SZBNamen on ANWENDER.USERNR = SZBNamen.userNr"); // WHERE GESPERRT <> 'J'");

            SqlCommand command = new SqlCommand(sql.ToString(), con);
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                ODALUser user = new ODALUser();
                user.UserID = DBTools.DBGetInt(reader, 0);
                user.Firma = DBTools.DBGetInt(reader, 1);
                user.Name = DBTools.DBGetString(reader, 2);
                user.Kostenstelle = DBTools.DBGetInt(reader, 3).ToString();
                user.Admin = DBTools.DBGetString(reader, 4) == "J" || DBTools.DBGetString(reader, 4) == "1";
                user.Freigabe = DBTools.DBGetString(reader, 5) == "J" || DBTools.DBGetString(reader, 5) == "1";                
                user.EMail = DBTools.DBGetString(reader, 6);
                user.Telefon = DBTools.DBGetString(reader, 8);
                user.Unterschrift = DBTools.DBGetString(reader, 9);
                user.Te = DBTools.DBGetString(reader, 10) == "J" || DBTools.DBGetString(reader, 10) == "1";
                user.DarfBestellungenErstelllen = DBTools.DBGetString(reader, 12) == "J" || DBTools.DBGetString(reader, 12) == "1";

                if (!reader.IsDBNull(7))
                {
                    user.Login = reader.GetString(7).Trim();

                    //Übernehmen der Informationen des angemeldetetn Users
                    if (user.Login.Trim().ToUpper() == this.angemeldeterUser.Login.Trim().ToUpper())
                    {
                        this.angemeldeterUser = user;
                        result = true;
                    }
                }
                if (DBTools.DBGetString(reader, 11).ToUpper() == "J")
                {
                    this.alleGesperrtenUser.Add(user.UserID, user);
                }
                else
                {
                    if (!alleUser.ContainsKey(user.UserID))
                    {
                        alleUser.Add(user.UserID, user);
                    }
                }
            }
            if (!result)
            {
#if DEBUG
                MessageBox.Show("Das Benutzerprofil: " + this.angemeldeterUser.Login + " ist in ODAl nicht vorhanden!", "WARNUNG!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
#endif
            }
            reader.Close();
            returnConnection(con);
            return result;
        }

        /// <summary>
        /// Nicht sicher ob das so klappt .. erzwingt das Neuladen der Informationen...
        /// </summary>
        /// <returns></returns>
        public static UserSingelton ResetInstance(string userName)
        {
            SingeltonManager.GetInstance().UnRegisterSigelton(me);
            me.userAustragen();
            me = null;
            return GetInstance(userName);
        }


        public ODALUser GetInfoTo(string userName)
        {
            ODALUser result = null;

            foreach (ODALUser u in this.alleUser.Values)
            {
                if (u.Name == userName)
                {
                    result = u;
                    break;
                }
            }
            if (result == null)
            {
                foreach (ODALUser u in this.alleGesperrtenUser.Values)
                {
                    if (u.Name == userName)
                    {
                        result = u;
                        break;
                    }
                }
            }

            return result;
        }

        public ODALUser GetInfoFromLogin(string userLogin)
        {
            ODALUser result = null;

            foreach (ODALUser u in this.alleUser.Values)
            {
                if (u.Login.ToUpper() == userLogin.ToUpper())
                {
                    result = u;
                    break;
                }
            }

            return result;
        }

        public ODALUser GetInfoTo(int userNr)
        {
            ODALUser result = null;

            if (this.alleUser.ContainsKey(userNr))
            {
                result = this.alleUser[userNr];
            }
            else if (this.alleGesperrtenUser.ContainsKey(userNr))
            {
                result = this.alleGesperrtenUser[userNr];
            }
            return result;
        }

        /// <summary>
        /// Hier werden alle Usernummern geladen die der angemeldete User Vertritt
        /// Ebenfalls werden Vertretungen von Vertretungen berücksichtigt.
        /// </summary>
        /// <param name="userNr"></param>
        /// <param name="con"></param>
        private void ladenVertreterKette(int userNr)
        {
            SqlConnection con = getConnection();
            //Vertretungen laden
            StringBuilder sql = new StringBuilder();
            sql.Append("select USERNR from ODAL.VERTRETUNGEN WHERE USERNRV = ");
            sql.Append(userNr);
            sql.Append(" and VON <= ");
            sql.Append(DBTools.Dat(DateTime.Now));
            sql.Append(" and BIS >= ");
            sql.Append(DBTools.Dat(DateTime.Now));
            try
            {
                SqlCommand command = new SqlCommand(sql.ToString(), con);
                SqlDataReader reader = command.ExecuteReader();
                int u;
                while (reader.Read())
                {
                    u = DBTools.DBGetInt(reader, 0);
                    if (u != 0 && !this.vertretungen.Contains(u)) //Sicherheitsabfrage zur Vermeidung von Endlosschleifen bei Zirkelbezügen der Vertretungen
                    {
                        //Überprüfen, ob es den zu vertretenden Benutzer noch gibt, ansonsten austragen der Vertretung
                        if (this.alleUser.ContainsKey(u) || this.alleGesperrtenUser.ContainsKey(u))
                        {
                            this.vertretungen.Add(u);
                            this.ladenVertreterKette(u);
                        }
                        else
                        {
                            this.vertretungLoeschen(u);
                        }
                    }
                }
                reader.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                throw;
            }
            returnConnection(con);
        }

        private void vertretungLoeschen(int u)
        {
            SqlConnection con = getConnection();
            //Vertretungen löschen
            StringBuilder sql = new StringBuilder();
            sql.Append("Delete from ODAL.VERTRETUNGEN WHERE USERNRV = ");
            sql.Append(u);
            sql.Append(" or USERNR = ");
            sql.Append(u);            
            try
            {
                SqlCommand command = new SqlCommand(sql.ToString(), con);
                command.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                throw;
            }
            returnConnection(con);
        }

        public Dictionary<int, ODALBereich> AlleBereiche
        {
            get 
            {
                if (alleBereiche == null)
                {
                    alleBereiche = new Dictionary<int, ODALBereich>();
                    this.alleBereicheLaden();
                }
                return alleBereiche;
            }
        }

        public Bereich GetBereichFürID(int bereichid)
        {
            Bereich result =null;
            if (FachBereiche.ContainsKey(bereichid))
            {
                result = this.fachBereiche[bereichid];
            }
            else if(AlleBereiche.ContainsKey(bereichid))
            {
                result = this.alleBereiche[bereichid];
            }
            return result;
        }

        /// <summary>
        /// Laden der Bereiche, die direkt und per Vertretung zugewiesen sind!
        /// </summary>
        /// <param name="con"></param>
        private void alleBereicheLaden()
        {
            SqlConnection con = getConnection();
            StringBuilder sql = new StringBuilder();
            //Bereiche für alle User laden (Selbst + Vertretungen)
            sql.Append("select ");
            sql.Append("BEREICHNR, ");
            sql.Append("BEREICH, ");
            sql.Append("S1, ");
            sql.Append("F1, ");
            sql.Append("S2, ");
            sql.Append("F2, ");
            sql.Append("S3, ");
            sql.Append("F3, ");
            sql.Append("TE, ");
            sql.Append("EMAIL, ");
            sql.Append("GESPERRT ");
            sql.Append("from ODAL.BEREICHE ");
            sql.Append("order by BEREICH");
            SqlCommand command = new SqlCommand(sql.ToString(), con);
            SqlDataReader reader = command.ExecuteReader();

            while (reader.Read())
            {
                int bereichID = DBTools.DBGetInt(reader, 0);
                if (!alleBereiche.ContainsKey(bereichID))
                {
                    //Bereich
                    ODALBereich bereich = new ODALBereich();
                    bereich.ID = bereichID;
                    bereich.Bezeichnung = DBTools.DBGetString(reader, 1);
                    bereich.Freigabe1 = DBTools.DBGetInt(reader, 2);
                    bereich.Freigeber1 = DBTools.DBGetInt(reader, 3);
                    bereich.Freigabe2 = DBTools.DBGetInt(reader, 4);
                    bereich.Freigeber2 = DBTools.DBGetInt(reader, 5);
                    bereich.Freigabe3 = DBTools.DBGetInt(reader, 6);
                    bereich.Freigeber3 = DBTools.DBGetInt(reader, 7);
                    bereich.TeFreigabeVorFreigabe = DBTools.DBGetInt(reader, 8);
                    bereich.EMail = DBTools.DBGetString(reader, 9);
                    if (!reader.IsDBNull(10))
                    {
                        bereich.Gesperrt = reader.GetDateTime(10);
                    }

                    alleBereiche.Add(bereichID, bereich);
                }
            }
            reader.Close();


            //AltBereicheLaden
            this.altBereiche = new List<ODALBereich>();
            sql = new StringBuilder();
            sql.Append("select ");
            sql.Append("BEREICHNR, ");
            sql.Append("BEREICH, ");
            sql.Append("S1, ");
            sql.Append("F1, ");
            sql.Append("S2, ");
            sql.Append("F2, ");
            sql.Append("S3, ");
            sql.Append("F3, ");
            sql.Append("TE, ");
            sql.Append("EMAIL, ");
            sql.Append("GBIS ");
            sql.Append("from ODAL.BEREICHE_ALT ");
            sql.Append("order by BEREICH");
            command = new SqlCommand(sql.ToString(), con);
            using(reader = command.ExecuteReader()) 
            {
                while (reader.Read())
                {
                    //Bereich
                    ODALBereich bereich = new ODALBereich();
                    bereich.ID = DBTools.DBGetInt(reader, 0);
                    bereich.Bezeichnung = DBTools.DBGetString(reader, 1);
                    bereich.Freigabe1 = DBTools.DBGetInt(reader, 2);
                    bereich.Freigeber1 = DBTools.DBGetInt(reader, 3);
                    bereich.Freigabe2 = DBTools.DBGetInt(reader, 4);
                    bereich.Freigeber2 = DBTools.DBGetInt(reader, 5);
                    bereich.Freigabe3 = DBTools.DBGetInt(reader, 6);
                    bereich.Freigeber3 = DBTools.DBGetInt(reader, 7);
                    bereich.TeFreigabeVorFreigabe = DBTools.DBGetInt(reader, 8);
                    bereich.EMail = DBTools.DBGetString(reader, 9);
                    bereich.GültigBis = DBTools.DBGetDate(reader, 10);

                    altBereiche.Add(bereich);
                }
            }

            returnConnection(con);
        }

        /// <summary>
        /// Gibt den zum Zeitpunkt der Bestellung gültigen Bereich zurück wenn vorhanden ODER
        /// </summary>
        /// <param name="bestellung"></param>
        /// <returns></returns>
        public ODALBereich GetBereichFürBestelldatum(ODALBestellung bestellung) 
        {
            ODALBereich result = null;

            if (altBereiche == null)
            {
                Object o = this.AlleBereiche;
            }

            if (bestellung.FreiVon1 == 0 && bestellung.FreiVon1 == 0 && bestellung.FreiVon1 == 0 && !bestellung.IstFreigegeben())
            {
                result = null;
            }
            else
            {
                foreach (ODALBereich b in altBereiche)
                {
                
                    if (b.ID == bestellung.Bereich)
                    {
                        if (b.GültigBis > bestellung.Datum)
                        {
                            if (result == null || result.GültigBis > b.GültigBis)
                            {
                                result = b;
                            }
                        }
                    }
                }
            }
            if (result == null)
            {
                if (bestellung.Bereich < 10000)
                {
                    result = alleBereiche[bestellung.Bereich];
                }
            }

            return result;
        }

        public bool userIsFreigabeBerechtigtAnFachbereich(int fachbereichsId)
        {
            bool result = false;
            if (angemeldeterUser != null)
            {
                result = userIsFreigabeBerechtigtAnFachbereich(angemeldeterUser.UserID, fachbereichsId);
            }
            return result;
        }

        public bool userIsFreigabeBerechtigtAnFachbereich(int userNR, int fachbereichsId)
        {
            bool result = false;

            if (this.fachBereiche != null)
            {
                foreach (FachBereich fb in this.fachBereiche.Values)
                {
                    if (fb.FachFreigeber.Contains(userNR))
                    {
                        result = true;
                        break;
                    }
                }
            }

            return result;
        }

        /// <summary>
        /// Alle Fachbereiche werden geladen und Freigabeberechtigte angefügt
        /// Anschließend werden alle Zugeordneten User geladen
        /// Anschließend wird das Teil SQL erstellt (Zur Besetllungseinschränkung)
        /// </summary>
        private void alleFachbereicheLaden()
        {
            this.fachBereiche = new Dictionary<int, FachBereich>();

            String sql = "select BEID, FIRMA, BEZEICHNUNG, FACHMINWERT, TE, TEMINWERT, GÜLTIGBIS, USERID, FIFI, OHNEFREIGABE, [VEREINFACHTEFG], TEXTAUFBEST from ODAL.FACHBEREICHE LEFT JOIN ODAL.FACHBEREICH_FREIGEBER on BEID = FBID order BY BEZEICHNUNG, BEID";
            using (SqlConnection con = new SqlConnection(DBTools.ConnectionStringODAL()))
            {
                con.Open();
                SqlCommand cmd = new SqlCommand(sql, con);
                using (SqlDataReader reader = cmd.ExecuteReader())
                {
                    if (reader.HasRows)
                    {
                        List<int> bereicheImSql = new List<int>();
                        FachBereich bereich = null;
                        while (reader.Read())
                        {
                            if (bereich == null || bereich.ID != reader.GetInt32(0))
                            {
                                bereich = new FachBereich();
                                bereich.ID = DBTools.DBGetInt(reader, 0);
                                bereich.Firma = DBTools.DBGetInt(reader, 1);
                                bereich.Bezeichnung = DBTools.DBGetString(reader, 2);
                                bereich.FachMinimumWertgrenze = DBTools.DBGetInt(reader, 3);
                                bereich.TEEinbinden = DBTools.DBGetBool(reader, 4);
                                bereich.TEMinimumWertgrenze = DBTools.DBGetInt(reader, 5);
                                if (!reader.IsDBNull(6))
                                {
                                    bereich.GültigBis = DBTools.DBGetDate(reader, 6);
                                }
                                if (!reader.IsDBNull(8))
                                {
                                    bereich.FirmenFilter = DBTools.DBGetBool(reader, 8);
                                }
                                if (!reader.IsDBNull(9))
                                {
                                    bereich.IstFachBereichOhneFreigabe = DBTools.DBGetBool(reader, 9);
                                }
                                if (!reader.IsDBNull(10))
                                {
                                    bereich.IstFachBereichMitVereinfachterFreigabe = DBTools.DBGetBool(reader, 10);
                                }
                                if (!reader.IsDBNull(11))
                                {
                                    bereich.KennungZusatzTextAufBestellung = DBTools.DBGetInt(reader, 11);
                                }

                                this.fachBereiche.Add(bereich.ID, bereich);
                            }
                            if (!reader.IsDBNull(7))
                            {
                                bereich.FachFreigeber.Add(DBTools.DBGetInt(reader, 7));
                            }
                        }
                    }
                }
            }
            
            this.userZuFachbereichenLaden();
            this.fachBereichsSqlErstellen();
        }

        private void fachBereichsSqlErstellen()
        {
            StringBuilder tempSql = new StringBuilder("BEREICH in (");
            String token = "";
            foreach (FachBereich fb in this.fachBereiche.Values)
            {
                foreach (int userID in this.vertretungen)
                {
                    if (fb.ZugeordneteUser.Contains(userID))
                    {
                        tempSql.Append(token);
                        tempSql.Append(fb.ID);

                        if (String.IsNullOrEmpty(token))
                        {
                            token = ", ";
                        }
                        break;
                    }
                }
            }
            tempSql.Append(")");
            //
            this.fachBereichsSQL = tempSql.ToString();
        }

        /// <summary>
        /// User werden den Bereichen zugeordnet
        /// </summary>
        private void userZuFachbereichenLaden()
        {
            String sql = "select ODAL.ANWENDER_X_FACHBEREICH.USERNR, FBID from ODAL.ANWENDER_X_FACHBEREICH left join ODAL.Anwender on ODAL.ANWENDER_X_FACHBEREICH.USERNR = ODAL.Anwender.USERNR where GESPERRT<> 'J' order BY FBID";
            using (SqlConnection con = new SqlConnection(DBTools.ConnectionStringODAL()))
            {
                con.Open();
                SqlCommand cmd = new SqlCommand(sql, con);
                using (SqlDataReader reader = cmd.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        int fbId = DBTools.DBGetInt(reader, 1);
                        if (this.fachBereiche.ContainsKey(fbId))
                        {
                            FachBereich b = this.fachBereiche[fbId];
                            int userId =  DBTools.DBGetInt(reader, 0);
                            if(!b.ZugeordneteUser.Contains(userId)) 
                            {
                                b.ZugeordneteUser.Add(userId);
                            }
                        }
                    }
                }

                sql = "select ODAL.FACHBEREICH_KONDI.USERID, FBID from ODAL.FACHBEREICH_KONDI left join ODAL.Anwender on ODAL.FACHBEREICH_KONDI.USERid = ODAL.Anwender.USERNR where GESPERRT<> 'J' order BY FBID";
                cmd = new SqlCommand(sql, con);
                using (SqlDataReader reader = cmd.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        int fbId = DBTools.DBGetInt(reader, 1);
                        if (this.fachBereiche.ContainsKey(fbId))
                        {
                            FachBereich b = this.fachBereiche[fbId];
                            int userId = DBTools.DBGetInt(reader, 0);
                            if (!b.AlternativeKonditionsFreigeber.Contains(userId))
                            {
                                b.AlternativeKonditionsFreigeber.Add(userId);
                            }
                        }
                    }
                }

                sql = "select ODAL.FACHBEREICH_DIREKT_FREI.USERID, FBID from ODAL.FACHBEREICH_DIREKT_FREI left join ODAL.Anwender on ODAL.FACHBEREICH_DIREKT_FREI.USERid = ODAL.Anwender.USERNR where GESPERRT<> 'J' order BY FBID";
                cmd = new SqlCommand(sql, con);
                using (SqlDataReader reader = cmd.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        int fbId = DBTools.DBGetInt(reader, 1);
                        if (this.fachBereiche.ContainsKey(fbId))
                        {
                            FachBereich b = this.fachBereiche[fbId];
                            int userId = DBTools.DBGetInt(reader, 0);
                            if (!b.VereinfachteFreigabeFreigeber.Contains(userId))
                            {
                                b.VereinfachteFreigabeFreigeber.Add(userId);
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Laden der Bereiche, die direkt und per Vertretung zugewiesen sind!
        /// </summary>
        /// <param name="con"></param>
        private void bereicheLaden()
        {
            SqlConnection con = getConnection();
            //Sammeln der Vertretungen für SQL
            StringBuilder vt = new StringBuilder();
            String token = "";
            foreach (int vert in this.vertretungen)
            {
                vt.Append(token);
                vt.Append(vert.ToString());
                if (String.IsNullOrEmpty(token))
                {
                    token = ", ";
                }
            }

            StringBuilder sql = new StringBuilder();
            //Bereiche für alle User laden (Selbst + Vertretungen)
            sql.Append("select ");
            sql.Append("ODAL.BEREICHE.BEREICHNR, ");
            sql.Append("ODAL.BEREICHE.BEREICH, ");
            sql.Append("ODAL.BEREICHE.S1, ");
            sql.Append("ODAL.BEREICHE.F1, ");
            sql.Append("ODAL.BEREICHE.S2, ");
            sql.Append("ODAL.BEREICHE.F2, ");
            sql.Append("ODAL.BEREICHE.S3, ");
            sql.Append("ODAL.BEREICHE.F3, ");
            sql.Append("ODAL.BEREICHE.TE, ");
            sql.Append("ODAL.BEREICHE.EMAIL, ");
            sql.Append("ODAL.ANWENDER_X_BEREICH.USERNR, ");
            sql.Append("ODAL.BEREICHE.GESPERRT ");
            sql.Append("from ODAL.ANWENDER_X_BEREICH left join ODAL.BEREICHE on ODAL.ANWENDER_X_BEREICH.BEREICHNR = ODAL.BEREICHE.BEREICHNR where USERNR in (");
            sql.Append(vt.ToString());
            sql.Append(") order by BEREICH");
            SqlCommand command = new SqlCommand(sql.ToString(), con);
            SqlDataReader reader = command.ExecuteReader();
           
            token = "";
            bereichsSQL.Append("BEREICH in (");
            while (reader.Read())
            {
                int bereichID = DBTools.DBGetInt(reader, 0);
                if (!bereiche.ContainsKey(bereichID))
                {
                    //SQL
                    bereichsSQL.Append(token);
                    bereichsSQL.Append(bereichID.ToString());
                    if (String.IsNullOrEmpty(token))
                    {
                        token = ", ";
                    }
                    //Bereich
                    ODALBereich bereich = new ODALBereich();
                    bereich.ID = bereichID;
                    bereich.Bezeichnung = DBTools.DBGetString(reader, 1);
                    bereich.Freigabe1 = DBTools.DBGetInt(reader, 2);
                    bereich.Freigeber1 = DBTools.DBGetInt(reader, 3);
                    bereich.Freigabe2 = DBTools.DBGetInt(reader, 4);
                    bereich.Freigeber2 = DBTools.DBGetInt(reader, 5);
                    bereich.Freigabe3 = DBTools.DBGetInt(reader, 6);
                    bereich.Freigeber3 = DBTools.DBGetInt(reader, 7);
                    bereich.TeFreigabeVorFreigabe = DBTools.DBGetInt(reader, 8);
                    bereich.EMail = DBTools.DBGetString(reader, 9);
                    bereich.FreigabeBerechtigt = UserIstfreigabeBerechtigt(DBTools.DBGetInt(reader, 10));
                    if(!reader.IsDBNull(11)) 
                    {
                        bereich.Gesperrt = reader.GetDateTime(11);
                    }
                    
                    bereiche.Add(bereichID, bereich);
                }
                else
                {
                    ODALBereich b = bereiche[bereichID];
                    if (!b.FreigabeBerechtigt)
                    {
                        b.FreigabeBerechtigt = UserIstfreigabeBerechtigt(DBTools.DBGetInt(reader, 10));
                    }
                }
            }
            bereichsSQL.Append(") ");
            reader.Close();
            returnConnection(con);
        }


        /// <summary>
        /// Überprüft ob der übergebene User die "Freigabeberechtigung" hat.
        /// (Vertretungen werden berücksichtigt)
        /// </summary>
        /// <param name="userNr"></param>
        /// <returns></returns>
        public bool UserIstfreigabeBerechtigt(int userNr)
        {
            bool result = false;

            if (alleUser.ContainsKey(userNr))
            {
                ODALUser u = alleUser[userNr];
                if (u.Freigabe)
                {
                    result = true;
                }
            }

            return result;
        }


        /// <summary>
        /// Holt zu der übergebenen User-Nummer das Kennwort.
        /// </summary>
        /// <param name="userNr"></param>
        /// <returns></returns>
        public bool StimmtKennwortÜberein(int userNr, string kennwort)
        {
            bool result = false;

            SqlConnection con = getConnection();
            string sql = "SELECT PASSWORT from ODAL.ANWENDER where USERNR = " + userNr;
            SqlCommand com = new SqlCommand(sql, con);
            SqlDataReader reader = com.ExecuteReader();
            string pw = null;

            while (reader.Read())
            {
                pw = this.decrypt(DBTools.DBGetStringUnTrimmed(reader, 0));
            }
            reader.Close();
            returnConnection(con);

            if (pw == kennwort)
            {
                result = true;
            }
            return result;
        }

        /// <summary>
        /// Verschlüsselt ein übergebens Paswort
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        private string encrypt(string text)
        {
            string result;
            int zeichen;

            result = "";
            for (int i = 0; i < text.Length; i++)
            {
                zeichen = (int)char.Parse(text.Substring(i, 1));
                zeichen = zeichen - 16;
                result = result + (char)zeichen;
            }
            return result;
        }

        /// <summary>
        /// Entschlüsselt ein übergebenes Kennwort
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        private string decrypt(string text)
        {
            string result = "";
            int zeichen;

            if (String.IsNullOrEmpty(text))
            {
                MessageBox.Show("Kein Kennwort vergeben!");
            }
            else
            {
                for (int i = 0; i < text.Length; i++)
                {

                    zeichen = (int)char.Parse(text.Substring(i, 1));
                    zeichen = zeichen + 16;
                    result = result + (char)zeichen;
                }
            }
            return result;
        }

        /// <summary>
        /// Überprüft ob der angemeldete User an dem übergebenen Bereich
        /// freigabeberechtigt ist.
        /// </summary>
        /// <param name="bereichsID"></param>
        /// <returns></returns>
        public bool freigebeBerechtigtAnBereich(int bereichsID)
        {
            bool result = false;

            if(this.bereiche.ContainsKey(bereichsID))
            {
                ODALBereich b = this.bereiche[bereichsID];
                if (b.FreigabeBerechtigt)
                {
                    result = true;
                }
            }

            return result;
        }

        //Gibt die einzige Instanz dieses Sigeltons heraus
        public static UserSingelton GetInstance() 
        {
            if (me == null || ODALParameterSingelton.GetInstance().DirtyUser)
            {
                try
                {
                    string name = WindowsIdentity.GetCurrent().Name;
                    string[] details = name.Split('\\');
                    me = new UserSingelton(details[details.Length - 1]);
                }
                catch (Exception)
                {
                    me = null;
                }
            }
            
            return me;
        }

        //Gibt die einzige Instanz dieses Sigeltons heraus
        public static UserSingelton GetInstance(string userName)
        {
            lock (padlock0)
            {
                if (me == null || ODALParameterSingelton.GetInstance().DirtyUser)
                {
                    me = new UserSingelton(userName);
                    SingeltonManager.GetInstance().RegisterSingelton(me);
                }

                return me;
            }
        }

        public int UserID
        {
            get { return this.angemeldeterUser.UserID; }
        }

        public List<String> ProjektNummernVorgabe
        {
            get { return this.angemeldeterUser.ProjektNummernVorgabe; }
        }

        public string Name
        {
            get { return this.angemeldeterUser.Name; }         
        }

        public string EMail
        {
            get { return this.angemeldeterUser.EMail; }         
        }

        public string Kostenstelle
        {
            get { return this.angemeldeterUser.Kostenstelle; }
        }

        public int Firma
        {
            get { return this.angemeldeterUser.Firma; }
        }

        /// <summary>
        /// Prüft ob der angemeldete User Adminrechte besitzt
        /// (Vertretungen werden berücksichtigt)
        /// </summary>
        public bool Admin
        {
            get 
            {
                bool result = angemeldeterUser.Admin;
                //Falls Vertretungen existieren muss der Admin status von den Vertetenen mit berüpcksichtigt werden
                if (!result && this.vertretungen.Count > 1) //Man ist selbst Mitglied dieser Liste daher >1
                {
                    for(int i = 1; i< this.vertretungen.Count; i++)
                    {
                        int userNr = this.vertretungen[i];
                        if (alleUser.ContainsKey(userNr))
                        {
                            ODALUser u = alleUser[userNr];
                            if (u.Admin)
                            {
                                result = true;
                                break;
                            }
                        }
                    }
                }
                return result; 
            }
        }

        /// <summary>
        /// Prüft ob der angemeldete User TE-Rechte besitzt
        /// (Vertretungen werden berücksichtigt)
        /// </summary>
        public bool TE
        {
            get
            {
                bool result = angemeldeterUser.Te;
                //Falls Vertretungen existieren muss der TE status von den Vertetenen mit berüpcksichtigt werden
                if (!result && this.vertretungen.Count > 1) //Man ist selbst Mitglied dieser Liste daher >1
                {
                    for (int i = 1; i < this.vertretungen.Count; i++)
                    {
                        int userNr = this.vertretungen[i];
                        if (alleUser.ContainsKey(userNr))
                        {
                            ODALUser u = alleUser[userNr];
                            if (u.Te)
                            {
                                result = true;
                                break;
                            }
                        }
                    }
                }
                return result;
            }
        }

        /// <summary>
        /// Überprüft ob der übergebene Name dem angemeldeten User entspricht.
        /// Vertretungen werden berücksichtigt!!!!!
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public bool DasBinIch(string name)
        {
            bool result = false;
            name = name.ToLower();
            foreach (int userNr in this.vertretungen)
            {
                if (alleUser.ContainsKey(userNr))
                {
                    if (alleUser[userNr].Name.ToLower() == name)
                    {
                        result = true;
                        break;
                    }
                }
                if (!result && alleGesperrtenUser.ContainsKey(userNr))
                {
                    if (alleGesperrtenUser[userNr].Name.ToLower() == name)
                    {
                        result = true;
                        break;
                    }
                }
            }
            return result;
        }

        public Dictionary<int, ODALBereich> Bereiche
        {
            get { return bereiche; }
        }

        public string GetBereichsSQL()
        {
            return bereichsSQL.ToString();
        }

        public ODALIni Parameter
        {
            get { return parameter; }
        }

        public List<int> Vertretungen
        {
            get { return vertretungen; }
        }
        public Dictionary<int, ODALUser> AlleUser
        {
            get { return alleUser; }
            set { alleUser = value; }
        }
        public Dictionary<int, ODALUser> AlleGesperrtenUser
        {
            get { return alleGesperrtenUser; }
            set { alleGesperrtenUser = value; }
        }

        public bool AngemeldeterUserDarfBestellungErfassen()
        {
            bool result = false;
            if (angemeldeterUser != null)
            {
                if (angemeldeterUser.DarfBestellungenErstelllen)
                {
                    result = true;
                }
            }
            return result;
        }

        /// <summary>
        /// Überprüft ob der User bei der Übergebenen Kombination von Parametern
        /// für die NÄCHSTE (nun benötigten Freigabe) freigabeberechtigt ist
        /// </summary>
        /// <param name="f1"></param>
        /// <param name="f2"></param>
        /// <param name="f3"></param>
        /// <param name="bereichsID"></param>
        /// <returns></returns>
        public bool angemeldeterUserDarfNächsteFreigabeErteilen(int f1, int f2, int f3, int bereichsID)
        {
            bool result = false;

            if (this.Admin)
            {
                result = true;
            }
            else
            {
                if (this.freigebeBerechtigtAnBereich(bereichsID))
                {
                    if (f1 == 0)
                    {
                        if (this.Vertretungen.Contains(this.Bereiche[bereichsID].Freigeber1))
                        {
                            result = true;
                        }
                    }
                    else if (f2 == 0)
                    {
                        if (this.Vertretungen.Contains(this.Bereiche[bereichsID].Freigeber2))
                        {
                            result = true;
                        }
                    }
                    else if (f3 == 0)
                    {
                        if (this.Vertretungen.Contains(this.Bereiche[bereichsID].Freigeber3))
                        {
                            result = true;
                        }
                    }
                }
            }

            return result;
        }

        public void ManagedKill() 
        {
            lock (padlock0)
            {
                if (me != null)
                {
                    me.userAustragen();
                }
                me = null;
            }
        }

        public void ManagedReset(string userName)
        {
            lock (padlock0)
            {
                if (String.IsNullOrEmpty(userName))
                {
                    me = null;
                }
                else
                {
                    me.userAustragen();
                    me = new UserSingelton(userName);
                }
            }
        }

        private void userEintragen()
        {
            this.userAustragen();

            SqlConnection con = getConnection();
            StringBuilder sql = new StringBuilder();
            sql.Append("insert into ODAL.AKTIVEODALUSER (TCPIP, LOGDATUM, USERNAME, VERSION) values(");
            sql.Append(DBTools.Txt(this.getIP()));
            sql.Append(", ");
            sql.Append(DBTools.DatTime(DateTime.Now));
            sql.Append(", ");
            sql.Append(DBTools.Txt(this.angemeldeterUser.Login));
            sql.Append(", ");
            sql.Append(DBTools.Txt(this.getVersion()));
            sql.Append(")");

            SqlCommand com = new SqlCommand(sql.ToString(), con);
            com.ExecuteNonQuery();
            returnConnection(con);
        }

        private void userAustragen()
        {
            SqlConnection con = getConnection();
            StringBuilder sql = new StringBuilder();
            sql.Append("delete from ODAL.AKTIVEODALUSER where USERNAME = ");
            sql.Append(DBTools.Txt(this.angemeldeterUser.Login));
            SqlCommand com = new SqlCommand(sql.ToString(), con);
            try
            {
                com.ExecuteNonQuery();
            }
            catch (Exception)
            {
                //Nothing
            }
            returnConnection(con);
        }

        private string getVersion()
        {
            string result = "";

            Version v = Assembly.GetExecutingAssembly().GetName().Version;
            result = "V" + v.Major + "." + v.Minor + "." + v.MajorRevision + "." + v.MinorRevision;

            return result;
        }

        public List<ODALBereich> AltBereiche
        {
            get { return altBereiche; }
            set { altBereiche = value; }
        }

        public void ResetFachbereiche()
        {
            this.alleFachbereicheLaden();
        }

        private string getIP()
        {
            string result = "";

            try
            {
                System.Net.IPHostEntry host = System.Net.Dns.GetHostEntry("");
                System.Net.IPAddress myIP = null;
                foreach (System.Net.IPAddress a in host.AddressList)
                {
                    if (a.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                    {
                        myIP = a;
                        break;
                    }
                }
                result = myIP.ToString();
            }
            catch (Exception)
            {
                result = "UNKNOWN";
            }

            return result;
        }

        public ODALUser GetUserFromFullName(string fullName)
        {
            ODALUser result = null;
            foreach (ODALUser u in alleUser.Values)
            {
                if (u.Name == fullName)
                {
                    result = u;
                    break;
                }
            }
            return result;
        }
    }
}