# ///
# database_service.py
# 描述：数据库服务层
# 作者：AI Generated
# 创建日期：2026-04-05
# ///

from typing import List, Optional, Dict, Any
from datetime import datetime

from models import DatabaseManager, Node, LogEntry, WebhookUrl, PluginConfig


class DatabaseService:
    def __init__(self, db_manager: DatabaseManager):
        self.db = db_manager

    # ==================== Node Operations ====================

    def get_all_nodes(self) -> List[Node]:
        session = self.db.get_session()
        try:
            return session.query(Node).all()
        finally:
            session.close()

    def get_node(self, node_id: str) -> Optional[Node]:
        session = self.db.get_session()
        try:
            return session.query(Node).filter(Node.node_id == node_id).first()
        finally:
            session.close()

    def get_nodes_by_group(self, group: str) -> List[Node]:
        session = self.db.get_session()
        try:
            return session.query(Node).filter(Node.group == group).all()
        finally:
            session.close()

    def get_enabled_nodes(self) -> List[Node]:
        session = self.db.get_session()
        try:
            return session.query(Node).filter(Node.enabled == True).all()
        finally:
            session.close()

    def add_node(self, node_id: str, name: str, api_url: str, api_key: str,
                 description: str = "", group: str = "default") -> bool:
        session = self.db.get_session()
        try:
            existing = session.query(Node).filter(Node.node_id == node_id).first()
            if existing:
                return False
            node = Node(
                node_id=node_id,
                name=name,
                api_url=api_url,
                api_key=api_key,
                description=description,
                group=group
            )
            session.add(node)
            session.commit()
            return True
        except Exception:
            session.rollback()
            return False
        finally:
            session.close()

    def update_node(self, node_id: str, **kwargs) -> bool:
        session = self.db.get_session()
        try:
            node = session.query(Node).filter(Node.node_id == node_id).first()
            if not node:
                return False
            for key, value in kwargs.items():
                if hasattr(node, key):
                    setattr(node, key, value)
            node.updated_at = datetime.now()
            session.commit()
            return True
        except Exception:
            session.rollback()
            return False
        finally:
            session.close()

    def delete_node(self, node_id: str) -> bool:
        session = self.db.get_session()
        try:
            node = session.query(Node).filter(Node.node_id == node_id).first()
            if not node:
                return False
            session.delete(node)
            session.commit()
            return True
        except Exception:
            session.rollback()
            return False
        finally:
            session.close()

    # ==================== Webhook Operations ====================

    def get_all_webhooks(self) -> List[WebhookUrl]:
        session = self.db.get_session()
        try:
            return session.query(WebhookUrl).all()
        finally:
            session.close()

    def get_webhook(self, webhook_id: int) -> Optional[WebhookUrl]:
        session = self.db.get_session()
        try:
            return session.query(WebhookUrl).filter(WebhookUrl.id == webhook_id).first()
        finally:
            session.close()

    def get_enabled_webhooks(self) -> List[WebhookUrl]:
        session = self.db.get_session()
        try:
            return session.query(WebhookUrl).filter(WebhookUrl.enabled == True).all()
        finally:
            session.close()

    def add_webhook(self, name: str, url: str, format: str = "bark",
                    event_types: List[str] = None) -> bool:
        session = self.db.get_session()
        try:
            webhook = WebhookUrl(
                name=name,
                url=url,
                format=format,
                event_types=",".join(event_types) if event_types else ""
            )
            session.add(webhook)
            session.commit()
            return True
        except Exception:
            session.rollback()
            return False
        finally:
            session.close()

    def update_webhook(self, webhook_id: int, **kwargs) -> bool:
        session = self.db.get_session()
        try:
            webhook = session.query(WebhookUrl).filter(WebhookUrl.id == webhook_id).first()
            if not webhook:
                return False
            for key, value in kwargs.items():
                if key == "event_types" and isinstance(value, list):
                    value = ",".join(value)
                if hasattr(webhook, key):
                    setattr(webhook, key, value)
            webhook.updated_at = datetime.now()
            session.commit()
            return True
        except Exception:
            session.rollback()
            return False
        finally:
            session.close()

    def delete_webhook(self, webhook_id: int) -> bool:
        session = self.db.get_session()
        try:
            webhook = session.query(WebhookUrl).filter(WebhookUrl.id == webhook_id).first()
            if not webhook:
                return False
            session.delete(webhook)
            session.commit()
            return True
        except Exception:
            session.rollback()
            return False
        finally:
            session.close()

    # ==================== Plugin Config Operations ====================

    def get_plugin_config(self, plugin_name: str) -> Optional[PluginConfig]:
        session = self.db.get_session()
        try:
            return session.query(PluginConfig).filter(PluginConfig.plugin_name == plugin_name).first()
        finally:
            session.close()

    def get_all_plugin_configs(self) -> List[PluginConfig]:
        session = self.db.get_session()
        try:
            return session.query(PluginConfig).all()
        finally:
            session.close()

    def save_plugin_config(self, plugin_name: str, config: Dict[str, Any], enabled: bool = False) -> bool:
        session = self.db.get_session()
        try:
            import json
            existing = session.query(PluginConfig).filter(PluginConfig.plugin_name == plugin_name).first()
            if existing:
                existing.config_json = json.dumps(config)
                existing.enabled = enabled
                existing.updated_at = datetime.now()
            else:
                plugin_config = PluginConfig(
                    plugin_name=plugin_name,
                    config_json=json.dumps(config),
                    enabled=enabled
                )
                session.add(plugin_config)
            session.commit()
            return True
        except Exception:
            session.rollback()
            return False
        finally:
            session.close()

    def update_plugin_enabled(self, plugin_name: str, enabled: bool) -> bool:
        session = self.db.get_session()
        try:
            plugin_config = session.query(PluginConfig).filter(PluginConfig.plugin_name == plugin_name).first()
            if plugin_config:
                plugin_config.enabled = enabled
                plugin_config.updated_at = datetime.now()
                session.commit()
                return True
            return False
        except Exception:
            session.rollback()
            return False
        finally:
            session.close()

    # ==================== Log Operations ====================

    def add_log(self, level: str, source: str, message: str) -> bool:
        session = self.db.get_session()
        try:
            log = LogEntry(
                level=level,
                source=source,
                message=message
            )
            session.add(log)
            session.commit()
            return True
        except Exception:
            session.rollback()
            return False
        finally:
            session.close()

    def get_recent_logs(self, count: int = 50) -> List[LogEntry]:
        session = self.db.get_session()
        try:
            return session.query(LogEntry).order_by(
                LogEntry.timestamp.desc()
            ).limit(count).all()
        finally:
            session.close()


_db_service: Optional[DatabaseService] = None
_db_manager: Optional[DatabaseManager] = None


def init_database(database_url: str):
    global _db_service, _db_manager
    _db_manager = DatabaseManager(database_url)
    _db_manager.create_tables()
    _db_service = DatabaseService(_db_manager)


def get_db_service() -> DatabaseService:
    return _db_service


def get_db_manager() -> DatabaseManager:
    return _db_manager