Projekt_SS25/Project_Periodensystem.Controller/PeriodensystemController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Project_Periodensystem.Model;
using Project_Periodensystem.Persistence;

namespace Project_Periodensystem.Controller
{
    /// <summary>
    /// Controller für das Periodensystem - verwaltet die Geschäftslogik
    /// und trennt View von Model gemäß MVC-Pattern
    /// </summary>
    public class PeriodensystemController
    {
        // Nullable Field um Warning zu vermeiden
        private List<Element> _elements = new List<Element>();

        /// <summary>
        /// Konstruktor - initialisiert den Controller
        /// </summary>
        public PeriodensystemController()
        {
            LoadElements();
        }

        /// <summary>
        /// Lädt alle Elemente über den Persistence-Layer
        /// </summary>
        private void LoadElements()
        {
            try
            {
                // Verwende die korrekte statische Methode aus PeriodicTableData
                _elements = PeriodicTableData.Elements.ToList();
                Logger.Log($"Controller: {_elements.Count} Elemente erfolgreich geladen");
            }
            catch (Exception ex)
            {
                Logger.Log($"EXCEPTION in LoadElements: {ex.Message}");
                _elements = new List<Element>();
            }
        }

        /// <summary>
        /// Gibt alle verfügbaren Elemente zurück
        /// </summary>
        /// <returns>Liste aller Elemente</returns>
        public List<Element> GetAllElements()
        {
            return _elements;
        }

        /// <summary>
        /// Sucht ein Element nach Atomnummer
        /// </summary>
        /// <param name="atomicNumber">Atomnummer des gesuchten Elements</param>
        /// <returns>Element oder null wenn nicht gefunden</returns>
        public Element? GetElementByAtomicNumber(int atomicNumber)
        {
            if (atomicNumber <= 0)
            {
                Logger.Log($"Ungültige Atomnummer: {atomicNumber}");
                return null;
            }

            return _elements.FirstOrDefault(e => e.AtomicNumber == atomicNumber);
        }

        /// <summary>
        /// Sucht ein Element nach Symbol
        /// </summary>
        /// <param name="symbol">Symbol des gesuchten Elements</param>
        /// <returns>Element oder null wenn nicht gefunden</returns>
        public Element? GetElementBySymbol(string symbol)
        {
            if (string.IsNullOrWhiteSpace(symbol))
            {
                Logger.Log("Leeres Symbol übergeben");
                return null;
            }

            return _elements.FirstOrDefault(e => 
                string.Equals(e.Symbol, symbol, StringComparison.OrdinalIgnoreCase));
        }

        /// <summary>
        /// Filtert Elemente nach Serie
        /// </summary>
        /// <param name="series">Gewünschte Elementserie</param>
        /// <returns>Liste der Elemente der angegebenen Serie</returns>
        public List<Element> GetElementsBySeries(string series)
        {
            if (string.IsNullOrWhiteSpace(series))
            {
                return new List<Element>();
            }

            return _elements.Where(e => 
                string.Equals(e.Series, series, StringComparison.OrdinalIgnoreCase))
                .ToList();
        }

        /// <summary>
        /// Validiert Grid-Position eines Elements
        /// </summary>
        /// <param name="element">Zu validierendes Element</param>
        /// <returns>True wenn Position gültig ist</returns>
        public bool ValidateElementPosition(Element element)
        {
            if (element == null)
            {
                Logger.Log("Null-Element kann nicht validiert werden");
                return false;
            }

            // Periodensystem hat 7 Perioden (0-6) und 18 Gruppen (0-17)
            // Plus Lanthanoid/Actinoid-Reihen bei Zeile 8 und 9
            bool validRow = element.Row >= 0 && element.Row <= 9;
            bool validColumn = element.Column >= 0 && element.Column <= 17;

            if (!validRow || !validColumn)
            {
                Logger.Log($"Ungültige Position für {element.Symbol}: ({element.Row},{element.Column})");
                return false;
            }

            return true;
        }

        /// <summary>
        /// Gibt alle verfügbaren Element-Serien zurück
        /// </summary>
        /// <returns>Liste aller Serien</returns>
        public List<string> GetAllSeries()
        {
            return _elements.Select(e => e.Series)
                           .Distinct()
                           .Where(s => !string.IsNullOrWhiteSpace(s))
                           .OrderBy(s => s)
                           .ToList();
        }

        /// <summary>
        /// Überprüft ob alle Elemente korrekt geladen wurden
        /// </summary>
        /// <returns>True wenn Daten vollständig sind</returns>
        public bool ValidateData()
        {
            if (_elements.Count == 0)
            {
                Logger.Log("Keine Elemente geladen");
                return false;
            }

            // Überprüfe auf Duplikate bei Atomnummern
            var duplicateNumbers = _elements.GroupBy(e => e.AtomicNumber)
                                           .Where(g => g.Count() > 1)
                                           .Select(g => g.Key);

            if (duplicateNumbers.Any())
            {
                Logger.Log($"Doppelte Atomnummern gefunden: {string.Join(", ", duplicateNumbers)}");
                return false;
            }

            // Überprüfe auf leere Symbole
            var emptySymbols = _elements.Where(e => string.IsNullOrWhiteSpace(e.Symbol));
            if (emptySymbols.Any())
            {
                Logger.Log("Elemente mit leeren Symbolen gefunden");
                return false;
            }

            Logger.Log($"Datenvalidierung erfolgreich - {_elements.Count} Elemente validiert");
            return true;
        }

        /// <summary>
        /// Lädt Daten neu (für Refresh-Funktionalität)
        /// </summary>
        public void RefreshData()
        {
            Logger.Log("Daten werden neu geladen...");
            LoadElements();
        }

        /// <summary>
        /// Gibt die Anzahl der geladenen Elemente zurück
        /// </summary>
        /// <returns>Anzahl der Elemente</returns>
        public int GetElementCount()
        {
            return _elements.Count;
        }
    }
}