import json
import os
from app.utils.logger import logger

DEFAULT_SYNC_MODE = "merge_local_primary"

CONFIG_PATH = os.path.abspath(
    os.path.join(os.path.dirname(__file__), "..", "config.json")
)


class ServerConfig:

    def __init__(self):
        self.theme = "auto"
        self.token = ""
        self.url = ""
        self.scheme = "https"
        self.port = "32400"
        self.library_name = ""
        self.sync_mode = DEFAULT_SYNC_MODE
        self.local_path = "playlist"
        self.path_rules: list[dict[str, str]] = []
        self.load()

    def load(self) -> None:
        try:
            with open(CONFIG_PATH, "r", encoding="utf-8") as f:
                config = json.load(f)
            logger.debug(f"Loaded server config: {config}")
        except FileNotFoundError:
            # 如果配置文件不存在，使用默认值
            self.save()
            logger.debug("Config file not found, using default values.")
            return
        except json.JSONDecodeError:
            # 如果配置文件格式错误，使用默认值
            self.save()
            logger.debug("Config file is invalid, using default values.")
            return
        self.theme = config.get("theme", "auto")
        self.token = config.get("token", "")
        self.url = config.get("server_url", "")
        self.scheme = config.get("server_scheme", "https")
        self.port = config.get("server_port", "32400")
        self.library_name = config.get("library_name", "")
        self.sync_mode = config.get("sync_mode", DEFAULT_SYNC_MODE)
        self.local_path = config.get("local_path", "playlist")
        self.path_rules = config.get("path_rules", []) or []
        logger.info(f"Server config loaded: {self.__dict__}")

    def save(self):
        config = {
            "theme": self.theme,
            "token": self.token,
            "server_url": self.url,
            "server_scheme": self.scheme,
            "server_port": self.port,
            "library_name": self.library_name,
            "sync_mode": self.sync_mode,
            "local_path": self.local_path,
            "path_rules": self.path_rules,
        }
        with open(CONFIG_PATH, "w", encoding="utf-8") as f:
            json.dump(config, f, indent=4, ensure_ascii=False)
        logger.info(f"Server config saved: {config}")

    def set_url(self, url: str) -> None:
        self.url = url

    def set_scheme(self, scheme: str) -> None:
        self.scheme = scheme

    def set_port(self, port: str) -> None:
        self.port = port

    def set_token(self, token: str) -> None:
        self.token = token

    def set_library(self, library_name: str) -> None:
        self.library_name = library_name or ""

    def set_sync_mode(self, sync_mode: str) -> None:
        self.sync_mode = sync_mode

    def set_local_path(self, local_path: str) -> None:
        self.local_path = local_path or "playlist"

    def set_theme(self, theme: str) -> None:
        # check theme is valid
        if theme not in ["auto", "dark", "light"]:
            logger.error(f"Invalid theme: {theme}")
            raise ValueError("Invalid theme. Must be 'auto', 'dark', or 'light'.")
        self.theme = theme

    def set_path_rules(self, path_rules: list[dict[str, str]]) -> None:
        self.path_rules = path_rules or []

    def set_and_save_config(
        self,
        theme: str = None,
        token: str = None,
        url: str = None,
        scheme: str = None,
        port: str = None,
        library_name: str | None = None,
        sync_mode: str | None = None,
        local_path: str | None = None,
        path_rules: list[dict[str, str]] | None = None,
    ) -> None:
        if theme is not None:
            self.set_theme(theme)
        if token is not None:
            self.set_token(token)
        if url is not None:
            self.set_url(url)
        if scheme is not None:
            self.set_scheme(scheme)
        if port is not None:
            self.set_port(port)
        if library_name is not None:
            self.set_library(library_name)
        if sync_mode is not None:
            self.set_sync_mode(sync_mode)
        if local_path is not None:
            self.set_local_path(local_path)
        if path_rules is not None:
            self.set_path_rules(path_rules)
        self.save()


server_config = ServerConfig()