ChronoFlow/ChronoFlow.Persistence/SqliteZeiterfassungsService.cs

using Microsoft.Data.Sqlite;
using ChronoFlow.Model;

namespace ChronoFlow.Persistence
{
    public class SqliteZeiterfassungsService
    {
        private readonly string _dbPath;
        private bool _dbInitialisiert ;

        public SqliteZeiterfassungsService()
        {
            _dbPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "chrono_data.sb");
            InitialisiereDatenbank();
        }

        private void InitialisiereDatenbank()
        {
            if (!File.Exists(_dbPath))
            {
                Console.WriteLine("📂 Datenbank existiert nicht. Erstelle neue...");
                ErstelleDatenbank();
            }
            else
            {
                Console.WriteLine("✅ Datenbankdatei gefunden: " + _dbPath);
            }

            _dbInitialisiert = true;
            ZeigeExistierendeTabellen();
        }

        private void ErstelleDatenbank()
        {
            using var connection = new SqliteConnection($"Data Source={_dbPath}");
            connection.Open();

            using (var cmd = connection.CreateCommand())
            {
                cmd.CommandText = @"
                    CREATE TABLE IF NOT EXISTS Zeiteintraege (
                        Id INTEGER PRIMARY KEY AUTOINCREMENT,
                        Mitarbeiter TEXT NOT NULL,
                        Startzeit TEXT NOT NULL,
                        Endzeit TEXT NOT NULL,
                        Projekt TEXT,
                        Kommentar TEXT,
                        Erledigt INTEGER,
                        MitarbeiterKommentar TEXT
                    );
                ";
                cmd.ExecuteNonQuery();
                Console.WriteLine("🛠️ Tabelle Zeiteintraege wurde erstellt/überprüft.");
            }

            using (var cmd = connection.CreateCommand())
            {
                cmd.CommandText = @"
                    CREATE TABLE IF NOT EXISTS Benutzer (
                        Id INTEGER PRIMARY KEY AUTOINCREMENT,
                        Username TEXT NOT NULL,
                        Password TEXT NOT NULL,
                        Role TEXT NOT NULL,
                        Mitarbeiternummer TEXT,
                        Abteilung TEXT
                    );
                ";
                cmd.ExecuteNonQuery();
                Console.WriteLine("🛠️ Tabelle Benutzer wurde erstellt/überprüft.");
            }
        }

        public void ErstelleStandardAdmin()
        {
            if (!_dbInitialisiert)
            {
                throw new Exception("❗ Fehler: Datenbank wurde noch nicht initialisiert!");
            }

            using var connection = new SqliteConnection($"Data Source={_dbPath}");
            connection.Open();

            var cmd = connection.CreateCommand();
            cmd.CommandText = @"
                INSERT INTO Benutzer (Username, Password, Role, Mitarbeiternummer, Abteilung)
                VALUES ('admin', 'admin', 'Admin', '0001', 'IT');
            ";
            cmd.ExecuteNonQuery();

            Console.WriteLine("✅ Standard-Admin erfolgreich erstellt.");
        }

        public void SpeichereEintrag(Zeiteintrag eintrag)
        {
            using var connection = new SqliteConnection($"Data Source={_dbPath}");
            connection.Open();

            var cmd = connection.CreateCommand();
            cmd.CommandText = @"
                INSERT INTO Zeiteintraege 
                (Mitarbeiter, Startzeit, Endzeit, Projekt, Kommentar, Erledigt, MitarbeiterKommentar)
                VALUES ($Mitarbeiter, $Startzeit, $Endzeit, $Projekt, $Kommentar, $Erledigt, $MitarbeiterKommentar);
            ";

            cmd.Parameters.AddWithValue("$Mitarbeiter", eintrag.Mitarbeiter);
            cmd.Parameters.AddWithValue("$Startzeit", eintrag.Startzeit.ToString("o"));
            cmd.Parameters.AddWithValue("$Endzeit", eintrag.Endzeit.ToString("o"));
            cmd.Parameters.AddWithValue("$Projekt", eintrag.Projekt ?? "");
            cmd.Parameters.AddWithValue("$Kommentar", eintrag.Kommentar ?? "");
            cmd.Parameters.AddWithValue("$Erledigt", eintrag.Erledigt ? 1 : 0);
            cmd.Parameters.AddWithValue("$MitarbeiterKommentar", eintrag.MitarbeiterKommentar ?? "");

            cmd.ExecuteNonQuery();
        }

        public List<Zeiteintrag> LadeAlleZeiteintraege()
        {
            var eintraege = new List<Zeiteintrag>();

            using var connection = new SqliteConnection($"Data Source={_dbPath}");
            connection.Open();

            var cmd = connection.CreateCommand();
            cmd.CommandText = "SELECT * FROM Zeiteintraege;";

            using var reader = cmd.ExecuteReader();
            while (reader.Read())
            {
                eintraege.Add(new Zeiteintrag
                {
                    Mitarbeiter = reader.GetString(1),
                    Startzeit = DateTime.Parse(reader.GetString(2)),
                    Endzeit = DateTime.Parse(reader.GetString(3)),
                    Projekt = reader.GetString(4),
                    Kommentar = reader.GetString(5),
                    Erledigt = Convert.ToInt32(reader["Erledigt"]) == 1,
                    MitarbeiterKommentar = reader.GetString(7)
                });
            }

            return eintraege;
        }

        public List<User> LadeAlleBenutzer()
        {
            var benutzerListe = new List<User>();

            using var connection = new SqliteConnection($"Data Source={_dbPath}");
            connection.Open();

            var cmd = connection.CreateCommand();
            cmd.CommandText = "SELECT Username, Password, Role, Mitarbeiternummer, Abteilung FROM Benutzer;";

            using var reader = cmd.ExecuteReader();
            while (reader.Read())
            {
                benutzerListe.Add(new User
                {
                    Username = reader.GetString(0),
                    Password = reader.GetString(1),
                    Role = reader.GetString(2),
                    Mitarbeiternummer = reader.IsDBNull(3) ? "" : reader.GetString(3),
                    Abteilung = reader.IsDBNull(4) ? "" : reader.GetString(4)
                });
            }

            return benutzerListe;
        }

        private void ZeigeExistierendeTabellen()
        {
            using var connection = new SqliteConnection($"Data Source={_dbPath}");
            connection.Open();

            var cmd = connection.CreateCommand();
            cmd.CommandText = "SELECT name FROM sqlite_master WHERE type='table';";

            using var reader = cmd.ExecuteReader();
            Console.WriteLine("🗂️ Tabellen in der Datenbank:");
            while (reader.Read())
            {
                Console.WriteLine($"   ➔ {reader.GetString(0)}");
            }
        }
        
        /// <summary>
        /// Prüft, ob ein Benutzername bereits existiert.
        /// </summary>
        /// <param name="username">Benutzername, der überprüft werden soll</param>
        /// <returns>True, wenn Name bereits existiert, sonst False</returns>
        public bool BenutzernameExistiert(string username)
        {
            using var connection = new SqliteConnection($"Data Source={_dbPath}");
            connection.Open();

            var cmd = connection.CreateCommand();
            cmd.CommandText = "SELECT COUNT(*) FROM Benutzer WHERE Username = $username";
            cmd.Parameters.AddWithValue("$username", username);

            var result = Convert.ToInt32(cmd.ExecuteScalar());

            return result > 0;
        }

    }
}