"""
Mozisarok Video Uploader - Központosított Beállításkezelő Modul
Egyetlen helyre gyűjti és kezeli a rendszer összes beállítását:
- Szerver & Biztonság (Port, Admin fiók állapot)
- Fájlböngésző & Mappa előzmények (Alapértelmezett és legutóbbi mappa)
- Lemezolvasás és RAM puffer korlát (128 MB alapértelmezett)
- Szolgáltatók (Videa/VK párhuzamosítás, szeletméretek, konvertálási limit)
- Mozisarok integráció (API és Embed konvertáló)
- MySQL Adatbázis kapcsolati információk (.env alapú)
- Verzió és frissítési információk
"""

from typing import Any, Dict, Optional
import os
from pathlib import Path

from config import (
    BASE_DIR,
    DB_HOST,
    DB_NAME,
    DB_POOL_SIZE,
    DB_PORT,
    DB_USER,
    DEFAULT_MAX_DISK_BUFFER_MB,
    DEFAULT_SERVER_PORT,
    DEFAULT_VIDEA_CHUNK_SIZE_MB,
    DEFAULT_VIDEA_CONCURRENCY,
    DEFAULT_VK_CHUNK_SIZE_MB,
    DEFAULT_VK_CONCURRENCY,
    EMBED_CONVERTER_URL,
    MAX_VIDEA_CONVERTING,
    MOZISAROK_API_BASE,
)
from database import get_admin_user, get_setting, has_admin_user, set_setting
from logger_config import get_logger
from updater import DEFAULT_UPDATE_SERVER_URL, get_update_server_url
from version import VERSION_INFO, __version__

logger = get_logger("SettingsManager")


def get_centralized_settings() -> Dict[str, Any]:
    """Összegyűjti az összes beállítást egy strukturált objektumban."""
    admin_record = get_admin_user()
    token = get_setting("mozisarok_token", "")

    # Mappa beállítások
    default_folder = get_setting("default_browse_folder", "")
    remember_folder = get_setting("remember_last_folder", "true").lower() in ("true", "1", "yes")
    last_folder = get_setting("last_browse_folder", str(BASE_DIR))

    # RAM és Lemezolvasás
    disk_buf = get_setting("max_disk_buffer_mb")
    max_disk_buffer = int(disk_buf) if disk_buf and disk_buf.isdigit() else DEFAULT_MAX_DISK_BUFFER_MB

    # Port
    port_val = get_setting("server_port")
    server_port = int(port_val) if port_val and port_val.isdigit() else DEFAULT_SERVER_PORT

    # Párhuzamosítás és szeletek
    v_conc = get_setting("videa_concurrency")
    videa_concurrency = int(v_conc) if v_conc and v_conc.isdigit() else DEFAULT_VIDEA_CONCURRENCY

    vk_conc = get_setting("vk_concurrency")
    vk_concurrency = int(vk_conc) if vk_conc and vk_conc.isdigit() else DEFAULT_VK_CONCURRENCY

    v_chunk = get_setting("videa_chunk_size_mb")
    videa_chunk_mb = int(v_chunk) if v_chunk and v_chunk.isdigit() else DEFAULT_VIDEA_CHUNK_SIZE_MB

    vk_chunk = get_setting("vk_chunk_size_mb")
    vk_chunk_mb = int(vk_chunk) if vk_chunk and vk_chunk.isdigit() else DEFAULT_VK_CHUNK_SIZE_MB

    max_converting = get_setting("max_videa_converting")
    videa_max_converting = int(max_converting) if max_converting and max_converting.isdigit() else MAX_VIDEA_CONVERTING

    return {
        "version": VERSION_INFO,
        "server": {
            "port": server_port,
            "has_admin": has_admin_user(),
            "admin_username": admin_record["username"] if admin_record else None,
        },
        "browser": {
            "default_browse_folder": default_folder,
            "remember_last_folder": remember_folder,
            "last_browse_folder": last_folder,
        },
        "performance": {
            "max_disk_buffer_mb": max_disk_buffer,
            "videa_concurrency": videa_concurrency,
            "vk_concurrency": vk_concurrency,
            "max_videa_converting": videa_max_converting,
            "videa_chunk_size_mb": videa_chunk_mb,
            "vk_chunk_size_mb": vk_chunk_mb,
        },
        "mozisarok": {
            "api_base": get_setting("mozisarok_api_base", MOZISAROK_API_BASE),
            "embed_converter_url": get_setting("embed_converter_url", EMBED_CONVERTER_URL),
            "has_token": bool(token),
            "token_preview": f"{token[:15]}..." if token and len(token) > 15 else (token or ""),
        },
        "database": {
            "host": DB_HOST,
            "port": DB_PORT,
            "user": DB_USER,
            "name": DB_NAME,
            "pool_size": DB_POOL_SIZE,
            "info": "Az adatbázis kapcsolati adatok biztonsági okokból a .env fájlban módosíthatók.",
        },
        "updates": {
            "server_url": get_update_server_url(),
            "current_version": __version__,
        },
    }


def save_centralized_settings(data: Dict[str, Any]) -> Dict[str, Any]:
    """Biztonságosan menti a frissített beállításokat."""
    # 1. Szerver port
    if "server_port" in data and data["server_port"] is not None:
        try:
            port = int(data["server_port"])
            if 1 <= port <= 65535:
                set_setting("server_port", str(port))
        except ValueError:
            pass

    # 2. Fájlböngésző beállítások
    if "default_browse_folder" in data:
        folder_str = str(data["default_browse_folder"] or "").strip()
        set_setting("default_browse_folder", folder_str)

    if "remember_last_folder" in data:
        rem = bool(data["remember_last_folder"])
        set_setting("remember_last_folder", "true" if rem else "false")

    # 3. Lemezolvasás RAM puffer optimalizálás
    if "max_disk_buffer_mb" in data and data["max_disk_buffer_mb"] is not None:
        try:
            buf_mb = max(8, min(int(data["max_disk_buffer_mb"]), 2048))
            set_setting("max_disk_buffer_mb", str(buf_mb))
        except ValueError:
            pass

    # 4. Párhuzamosítás és szeletek
    if "videa_concurrency" in data and data["videa_concurrency"] is not None:
        try:
            vc = max(1, min(int(data["videa_concurrency"]), 10))
            set_setting("videa_concurrency", str(vc))
        except ValueError:
            pass

    if "vk_concurrency" in data and data["vk_concurrency"] is not None:
        try:
            vkc = max(1, min(int(data["vk_concurrency"]), 10))
            set_setting("vk_concurrency", str(vkc))
        except ValueError:
            pass

    if "max_videa_converting" in data and data["max_videa_converting"] is not None:
        try:
            mvc = max(1, min(int(data["max_videa_converting"]), 50))
            set_setting("max_videa_converting", str(mvc))
        except ValueError:
            pass

    if "videa_chunk_size_mb" in data and data["videa_chunk_size_mb"] is not None:
        try:
            v_chunk = max(1, min(int(data["videa_chunk_size_mb"]), 128))
            set_setting("videa_chunk_size_mb", str(v_chunk))
        except ValueError:
            pass

    if "vk_chunk_size_mb" in data and data["vk_chunk_size_mb"] is not None:
        try:
            vk_chunk = max(1, min(int(data["vk_chunk_size_mb"]), 128))
            set_setting("vk_chunk_size_mb", str(vk_chunk))
        except ValueError:
            pass

    # 5. Mozisarok és Converter
    if "mozisarok_api_base" in data and data["mozisarok_api_base"]:
        set_setting("mozisarok_api_base", data["mozisarok_api_base"].strip())

    if "embed_converter_url" in data and data["embed_converter_url"]:
        set_setting("embed_converter_url", data["embed_converter_url"].strip())

    if "mozisarok_token" in data and data["mozisarok_token"]:
        tok = data["mozisarok_token"].strip()
        if tok and not tok.startswith("****"):
            set_setting("mozisarok_token", tok)

    # 6. Frissítési szerver URL
    if "update_server_url" in data and data["update_server_url"] is not None:
        url = str(data["update_server_url"]).strip().rstrip("/")
        if url:
            set_setting("update_server_url", url)

    logger.info("Központi beállítások sikeresen elmentve.")
    return get_centralized_settings()
