# -*- coding: utf-8 -*-
"""
Abstrakte Basisklasse fuer alle Trixy-Trainer.

Trainer laufen als isolierter Subprocess und sind
unabhaengig vom Event-Loop der Hauptanwendung.
"""

from abc import ABC, abstractmethod
from multiprocessing import Queue, Event as MPEvent

from trixy_core.trainer.dataclasses import (
    TrainerInfo,
    TrainingProgress,
    ValidationResult,
    FormSchema,
)


class ITrainer(ABC):
    """
    Abstrakte Basisklasse fuer ML-Trainer.

    Jeder Trainer implementiert Schema-Methoden fuer die TUI
    und die eigentliche Trainingslogik.
    """

    @abstractmethod
    def get_info(self) -> TrainerInfo:
        """Liefert Metadaten des Trainers."""

    @abstractmethod
    def get_settings_schema(self) -> FormSchema:
        """Liefert das Formular-Schema fuer Trainings-Einstellungen."""

    @abstractmethod
    def get_dataset_schema(self) -> FormSchema:
        """Liefert das Formular-Schema fuer Dataset-Konfiguration."""

    def get_optional_schema(self) -> FormSchema | None:
        """Liefert optionales Schema (None = Tab ausblenden)."""
        return None

    @abstractmethod
    def get_settings(self) -> dict:
        """Liefert die aktuellen Einstellungswerte."""

    @abstractmethod
    def set_settings(self, settings: dict) -> None:
        """Setzt Einstellungswerte aus dem Formular."""

    @abstractmethod
    def get_dataset_info(self) -> dict:
        """Liefert aktuelle Dataset-Informationen."""

    def set_dataset_config(self, config: dict) -> None:
        """Setzt Dataset-Konfiguration aus dem Formular."""
        pass

    @abstractmethod
    def validate(self) -> ValidationResult:
        """Validiert Einstellungen und Dataset vor dem Training."""

    @abstractmethod
    def train(
        self,
        progress_queue: Queue,
        pause_flag: MPEvent,
        stop_flag: MPEvent,
    ) -> None:
        """
        Fuehrt das Training durch (laeuft im Subprocess).

        Args:
            progress_queue: Queue fuer TrainingProgress-Updates
            pause_flag: Gesetzt wenn Training pausiert werden soll
            stop_flag: Gesetzt wenn Training gestoppt werden soll
        """

    def pause(self) -> None:
        """Zusaetzliche Pause-Logik (optional)."""
        pass

    def resume(self) -> None:
        """Zusaetzliche Resume-Logik (optional)."""
        pass

    def stop(self) -> None:
        """Zusaetzliche Stop-Logik (optional)."""
        pass

    def execute_action(self, action: str, params: dict) -> dict:
        """
        Fuehrt eine benannte Aktion aus (z.B. TTS-Datengenerierung).

        Args:
            action: Name der Aktion
            params: Parameter fuer die Aktion

        Returns:
            dict mit "success" (bool), "message" (str), optionalen Daten
        """
        return {"success": False, "message": f"Aktion '{action}' nicht unterstuetzt"}