import asyncpg
import json
import logging
import uuid
from typing import Dict, List, Optional, Any

# ==========================================
# 💡 PostgreSQL 連線與操作 (高可用性版)
# ==========================================

logger = logging.getLogger(__name__)

# DB 設定 (從您的 init_db.py 中提取)
DB_CONFIG = {
    "database": "cmts_nms",
    "user": "swpa",
    "password": "swpa4920",
    "host": "127.0.0.1",
    "port": "5432"
}

_pool: Optional[asyncpg.Pool] = None

async def init_db_pool():
    """初始化非同步連線池"""
    global _pool
    try:
        if _pool is None:
            _pool = await asyncpg.create_pool(
                database=DB_CONFIG["database"],
                user=DB_CONFIG["user"],
                password=DB_CONFIG["password"],
                host=DB_CONFIG["host"],
                port=int(DB_CONFIG["port"]),
                min_size=1,
                max_size=10
            )
            logger.info("✅ PostgreSQL Connection Pool Initialized.")
    except Exception as e:
        logger.error(f"❌ Failed to initialize DB Pool: {e}")

async def close_db_pool():
    """關閉非同步連線池"""
    global _pool
    if _pool:
        await _pool.close()
        _pool = None
        logger.info("🔌 PostgreSQL Connection Pool Closed.")

async def get_pool() -> Optional[asyncpg.Pool]:
    if _pool is None:
        await init_db_pool()
    return _pool

# ------------------------------------------
# CRUD Functions for cmts_options
# ------------------------------------------

async def upsert_leaf_option(host: str, config_type: str, path: str, data: dict) -> bool:
    """將選項寫入或更新至資料庫"""
    pool = await get_pool()
    if not pool:
        return False
        
    query = """
        INSERT INTO cmts_options (host, config_type, path, data)
        VALUES ($1, $2, $3, $4)
        ON CONFLICT (host, config_type, path)
        DO UPDATE SET data = EXCLUDED.data, updated_at = CURRENT_TIMESTAMP;
    """
    try:
        async with pool.acquire() as conn:
            await conn.execute(query, host, config_type, path, json.dumps(data))
        return True
    except asyncpg.PostgresError as e:
        logger.error(f"❌ DB Error (upsert_leaf_option): {e}")
        return False
    except Exception as e:
        logger.error(f"❌ Unknown Error (upsert_leaf_option): {e}")
        return False

async def get_all_leaf_options(host: str, config_type: str) -> Optional[Dict[str, Any]]:
    """取得特定 host 與 config_type 的所有選項"""
    pool = await get_pool()
    if not pool:
        return None
        
    query = """
        SELECT path, data FROM cmts_options 
        WHERE host = $1 AND config_type = $2;
    """
    try:
        async with pool.acquire() as conn:
            records = await conn.fetch(query, host, config_type)
            result = {}
            for record in records:
                # asyncpg returns strings for JSON if not explicitly configured with type mapping,
                # but usually it's fine to just json.loads it.
                data_val = record['data']
                if isinstance(data_val, str):
                    result[record['path']] = json.loads(data_val)
                else:
                    result[record['path']] = data_val
            return result
    except asyncpg.PostgresError as e:
        logger.error(f"❌ DB Error (get_all_leaf_options): {e}")
        return None
    except Exception as e:
        logger.error(f"❌ Unknown Error (get_all_leaf_options): {e}")
        return None

async def delete_leaf_options(host: str, config_type: str, paths: List[str]) -> int:
    """刪除特定路徑的選項快取"""
    pool = await get_pool()
    if not pool or not paths:
        return -1
        
    query = """
        DELETE FROM cmts_options 
        WHERE host = $1 AND config_type = $2 AND path = ANY($3);
    """
    try:
        async with pool.acquire() as conn:
            # Execute returns the command tag, e.g., 'DELETE 5'
            status = await conn.execute(query, host, config_type, paths)
            deleted_count = int(status.split()[-1])
            return deleted_count
    except asyncpg.PostgresError as e:
        logger.error(f"❌ DB Error (delete_leaf_options): {e}")
        return -1
    except Exception as e:
        logger.error(f"❌ Unknown Error (delete_leaf_options): {e}")
        return -1

# ------------------------------------------
# CRUD Functions for device_status
# ------------------------------------------

async def upsert_device_status(host: str, config_type: str, metadata: dict) -> bool:
    """更新設備的 metadata"""
    pool = await get_pool()
    if not pool:
        return False
        
    # Extract known fields
    cmts_version = metadata.get("cmts_version", "unknown")
    last_scanned = metadata.get("last_scanned", None)
    
    query = """
        INSERT INTO device_status (host, config_type, cmts_version, last_scanned)
        VALUES ($1, $2, $3, $4)
        ON CONFLICT (host, config_type)
        DO UPDATE SET 
            cmts_version = EXCLUDED.cmts_version, 
            last_scanned = EXCLUDED.last_scanned,
            updated_at = CURRENT_TIMESTAMP;
    """
    try:
        async with pool.acquire() as conn:
            await conn.execute(query, host, config_type, cmts_version, last_scanned)
        return True
    except asyncpg.PostgresError as e:
        logger.error(f"❌ DB Error (upsert_device_status): {e}")
        return False
    except Exception as e:
        logger.error(f"❌ Unknown Error (upsert_device_status): {e}")
        return False

async def get_device_status(host: str, config_type: str) -> Optional[Dict[str, Any]]:
    """獲取設備 metadata"""
    pool = await get_pool()
    if not pool:
        return None
        
    query = """
        SELECT cmts_version, last_scanned FROM device_status 
        WHERE host = $1 AND config_type = $2;
    """
    try:
        async with pool.acquire() as conn:
            record = await conn.fetchrow(query, host, config_type)
            if record:
                return {
                    "cmts_version": record["cmts_version"],
                    "last_scanned": record["last_scanned"]
                }
            return None
    except asyncpg.PostgresError as e:
        logger.error(f"❌ DB Error (get_device_status): {e}")
        return None
    except Exception as e:
        logger.error(f"❌ Unknown Error (get_device_status): {e}")
        return None

# ------------------------------------------
# CRUD Functions for system_filters (Tree Filters)
# ------------------------------------------
async def upsert_tree_filters(config_type: str, hidden_keys: List[str]) -> bool:
    """寫入全域的樹狀圖隱藏節點名單"""
    pool = await get_pool()
    if not pool:
        return False
        
    # Use 'global' as a dummy host to keep schema simple if needed, 
    # but a dedicated system_filters table is better.
    query = """
        INSERT INTO system_filters (config_type, hidden_keys)
        VALUES ($1, $2)
        ON CONFLICT (config_type)
        DO UPDATE SET hidden_keys = EXCLUDED.hidden_keys, updated_at = CURRENT_TIMESTAMP;
    """
    try:
        async with pool.acquire() as conn:
            await conn.execute(query, config_type, hidden_keys)
        return True
    except asyncpg.PostgresError as e:
        logger.error(f"❌ DB Error (upsert_tree_filters): {e}")
        return False
    except Exception as e:
        logger.error(f"❌ Unknown Error (upsert_tree_filters): {e}")
        return False

async def get_tree_filters(config_type: str) -> Optional[List[str]]:
    """讀取全域的樹狀圖隱藏節點名單"""
    pool = await get_pool()
    if not pool:
        return None
        
    query = """
        SELECT hidden_keys FROM system_filters 
        WHERE config_type = $1;
    """
    try:
        async with pool.acquire() as conn:
            record = await conn.fetchrow(query, config_type)
            if record:
                return record["hidden_keys"]
            return []
    except asyncpg.PostgresError as e:
        logger.error(f"❌ DB Error (get_tree_filters): {e}")
        return None
    except Exception as e:
        logger.error(f"❌ Unknown Error (get_tree_filters): {e}")
        return None

# ==========================================
# CRUD Functions for config_backups (Phase 1 & 2)
# ==========================================

async def insert_config_backup(
    host: str, 
    config_type: str, 
    raw_cli: str, 
    parsed_tree: dict, 
    snapshot_name: Optional[str] = None, 
    is_auto: bool = False
) -> Optional[str]:
    """新增一筆設備配置備份，回傳產生的 Backup ID"""
    pool = await get_pool()
    if not pool:
        return None
        
    backup_id = str(uuid.uuid4())
    
    query = """
        INSERT INTO config_backups 
        (id, host, config_type, snapshot_name, is_auto, raw_cli, parsed_tree)
        VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)
    """
    try:
        async with pool.acquire() as conn:
            await conn.execute(
                query, 
                backup_id, 
                host, 
                config_type, 
                snapshot_name, 
                is_auto, 
                raw_cli, 
                json.dumps(parsed_tree)
            )
        return backup_id
    except asyncpg.PostgresError as e:
        logger.error(f"❌ DB Error (insert_config_backup): {e}")
        return None
    except Exception as e:
        logger.error(f"❌ Unknown Error (insert_config_backup): {e}")
        return None

async def get_config_backup_list(host: str, config_type: str) -> Optional[List[Dict[str, Any]]]:
    """取得歷史快照列表 (輕量級，不含完整設定檔內容)"""
    pool = await get_pool()
    if not pool:
        return None
        
    query = """
        SELECT id, host, config_type, timestamp, snapshot_name, is_auto 
        FROM config_backups 
        WHERE host = $1 AND config_type = $2
        ORDER BY timestamp DESC;
    """
    try:
        async with pool.acquire() as conn:
            records = await conn.fetch(query, host, config_type)
            # 將 asyncpg 的 Record 轉為 dict，並將 datetime 轉為字串方便 JSON 序列化
            return [
                {
                    "id": str(r["id"]),
                    "host": r["host"],
                    "config_type": r["config_type"],
                    "timestamp": r["timestamp"].isoformat(),
                    "snapshot_name": r["snapshot_name"],
                    "is_auto": r["is_auto"]
                }
                for r in records
            ]
    except asyncpg.PostgresError as e:
        logger.error(f"❌ DB Error (get_config_backup_list): {e}")
        return None
    except Exception as e:
        logger.error(f"❌ Unknown Error (get_config_backup_list): {e}")
        return None

async def get_config_backup_detail(backup_id: str) -> Optional[Dict[str, Any]]:
    """取得特定快照的完整內容 (包含 parsed_tree，供 Phase 3 還原使用)"""
    pool = await get_pool()
    if not pool:
        return None
        
    query = """
        SELECT id, timestamp, snapshot_name, is_auto, parsed_tree 
        FROM config_backups 
        WHERE id = $1;
    """
    try:
        async with pool.acquire() as conn:
            record = await conn.fetchrow(query, backup_id)
            if record:
                data_val = record['parsed_tree']
                parsed_tree = json.loads(data_val) if isinstance(data_val, str) else data_val
                
                return {
                    "id": str(record["id"]),
                    "timestamp": record["timestamp"].isoformat(),
                    "snapshot_name": record["snapshot_name"],
                    "is_auto": record["is_auto"],
                    "parsed_tree": parsed_tree
                }
            return None
    except asyncpg.PostgresError as e:
        logger.error(f"❌ DB Error (get_config_backup_detail): {e}")
        return None
    except Exception as e:
        logger.error(f"❌ Unknown Error (get_config_backup_detail): {e}")
        return None

async def delete_config_backup(backup_id: str) -> bool:
    """刪除指定的快照"""
    pool = await get_pool()
    if not pool:
        return False
        
    query = "DELETE FROM config_backups WHERE id = $1;"
    try:
        async with pool.acquire() as conn:
            status = await conn.execute(query, backup_id)
            # status 會是 'DELETE 1' 或 'DELETE 0'
            return int(status.split()[-1]) > 0
    except asyncpg.PostgresError as e:
        logger.error(f"❌ DB Error (delete_config_backup): {e}")
        return False
    except Exception as e:
        logger.error(f"❌ Unknown Error (delete_config_backup): {e}")
        return False