"""
CANIFA Stock Check Tool - Kiểm tra tồn kho qua API Canifa.
"""

import json
import logging

import httpx
from langchain_core.tools import tool
from pydantic import BaseModel, Field

logger = logging.getLogger(__name__)

# API Canifa stock
CANIFA_STOCK_API = "https://canifa.com/v1/middleware/stock_get_stock_list_parent"


class StockCheckInput(BaseModel):
    model_config = {"extra": "forbid"}
    
    skus: str = Field(
        description=(
            "Mã sản phẩm cần kiểm tra tồn kho. "
            "Chấp nhận base code (VD: '6TS25S018') hoặc product_color_code (VD: '5TS25S023-SY322'). "
            "⚠️ TUYỆT ĐỐI KHÔNG tự bịa/ghép suffix — truyền ĐÚNG mã khách đưa."
        )
    )


async def fetch_stock_from_canifa(skus: list[str], timeout: float = 5.0) -> dict:
    """
    Gọi API Canifa để lấy thông tin tồn kho.
    
    Args:
        skus: List of product_color_code (e.g., ['5TS25S023-SY322'])
        timeout: Request timeout in seconds
    
    Returns:
        Raw API response as dict
    """
    if not skus:
        return {}
    
    sku_string = ",".join(skus)
    url = f"{CANIFA_STOCK_API}?skus={sku_string}"
    
    try:
        async with httpx.AsyncClient(timeout=timeout) as client:
            resp = await client.get(url)
            resp.raise_for_status()
            data = resp.json()
            
            logger.info(f"📦 Stock API response: {len(data.get('result', []))} variants")
            
            # Save fetched data to redis right away for background cache consistency
            try:
                from common.cache import redis_cache
                r_client = redis_cache.get_client()
                if r_client and "result" in data and isinstance(data["result"], list):
                    pipe = r_client.pipeline()
                    for item in data["result"]:
                        sku = item.get("sku") or item.get("product_color_code", "")
                        if sku:
                            pipe.setex(f"stock:{sku}", 300, json.dumps(item, ensure_ascii=False))
                    await pipe.execute()
            except Exception as e:
                logger.error(f"Failed to background push missed cache to redis: {e}")
                
            return data
            
    except httpx.TimeoutException:
        logger.warning(f"⏰ Stock API timeout ({timeout}s)")
        return {"code": 500, "error": "timeout"}
    except Exception as e:
        logger.error(f"❌ Stock API error: {e}")
        return {"code": 500, "error": str(e)}


@tool("check_is_stock", args_schema=StockCheckInput)
async def check_is_stock(skus: str) -> str:
    """
    Kiểm tra tồn kho sản phẩm CANIFA.
    Trả về thông tin còn hàng theo từng size.
    """
    if not skus:
        return json.dumps({"error": "Thiếu mã sản phẩm để kiểm tra tồn kho"})
    
    # Parse SKUs
    sku_list = [s.strip() for s in skus.split(",") if s.strip()]
    
    if not sku_list:
        return json.dumps({"error": "Không có mã sản phẩm hợp lệ"})
    
    cached_results = []
    missing_skus = []
    
    try:
        from common.cache import redis_cache
        client = redis_cache.get_client()
        if client:
            for sku in sku_list:
                item_str = await client.get(f"stock:{sku}")
                if item_str:
                    cached_results.append(json.loads(item_str))
                else:
                    missing_skus.append(sku)
        else:
            missing_skus = sku_list
    except Exception as e:
        logger.error(f"Cache check error: {e}")
        missing_skus = sku_list
    
    if missing_skus:
        # Lấy từ API cho các mã còn thiếu
        stock_data = await fetch_stock_from_canifa(missing_skus)
        # Gộp chung vào nếu có
        if "result" in stock_data and isinstance(stock_data["result"], list):
            cached_results.extend(stock_data["result"])
    
    # Trả về format chung giống hệt raw API để AI không bị ảnh hưởng logic
    final_data = {"result": cached_results, "source": "redis_cached" if not missing_skus else "mixed"}
    
    return json.dumps(final_data, ensure_ascii=False)


