"""
Design Image Search FastAPI Application
Design 图像搜索 FastAPI 服务
"""

import os
import uuid
import time
import yaml
import logging
from datetime import datetime, timedelta
from typing import Optional, Dict, Any, List
from pathlib import Path
from contextlib import asynccontextmanager

import uvicorn
from fastapi import FastAPI, UploadFile, File, Form, HTTPException, Depends, Header
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
import numpy as np
from dotenv import load_dotenv
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.triggers.cron import CronTrigger


# 尝试导入不同的 JWT 库
try:
    import jwt
    # 检查是否有 encode/decode 方法
    if not hasattr(jwt, 'encode') or not hasattr(jwt, 'decode'):
        # 如果没有，尝试 python-jose
        from jose import jwt
except ImportError:
    # 如果都失败了，尝试 python-jose
    from jose import jwt

from database import DatabaseManager
from core.search_engine import ImageSearchEngine
from core.faiss_manager import FAISSManager
from core.memory_index import InMemoryIndex
from data_sync import DesignDataSync

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# 全局变量
config = None
db_manager = None
search_engine = None
data_sync = None
sync_thread = None
scheduler = None
# 全局 FAISS 管理器实例
faiss_manager = None

os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'

def load_config():
    """加载配置文件"""
    global config
    with open('config.yml', 'r', encoding='utf-8') as f:
        config = yaml.safe_load(f)

    # 替换环境变量
    def replace_env_vars(obj):
        if isinstance(obj, dict):
            return {k: replace_env_vars(v) for k, v in obj.items()}
        elif isinstance(obj, list):
            return [replace_env_vars(item) for item in obj]
        elif isinstance(obj, str) and obj.startswith('${') and obj.endswith('}'):
            env_var = obj[2:-1]
            default = None
            if ':' in env_var:
                env_var, default = env_var.split(':', 1)
            return os.getenv(env_var, default)
        return obj

    config = replace_env_vars(config)
    return config


def scheduled_sync():
    """定时任务：每天 0:00 和 12:00 执行增量同步"""
    try:
        logger.info("🔄 定时任务：开始增量同步")
        result = data_sync.sync_once()
        logger.info(f"✅ 定时同步完成: {result}")
    except Exception as e:
        logger.error(f"❌ 定时同步失败: {e}", exc_info=True)


def check_faiss_index_update():
    """检查FAISS索引文件是否有更新，必要时重载"""
    global faiss_manager

    # 如果全局 faiss_manager 未初始化，直接返回
    if faiss_manager is None:
        return

    try:
        import os

        index_path = config['faiss']['index_path']
        mapping_path = config['faiss']['mapping_path']
        tombstone_path = config['faiss']['tombstone_path']

        # 检查所有相关文件是否存在
        if not all(os.path.exists(p) for p in [index_path, mapping_path, tombstone_path]):
            return

        # 获取文件修改时间
        current_mtime = max(
            os.path.getmtime(index_path),
            os.path.getmtime(mapping_path),
            os.path.getmtime(tombstone_path)
        )

        # 初始化或检查上次加载时间
        if not hasattr(check_faiss_index_update, 'last_mtime'):
            check_faiss_index_update.last_mtime = current_mtime
            return

        # 如果文件有更新，重载索引
        if current_mtime > check_faiss_index_update.last_mtime:
            logger.info("检测到FAISS索引文件更新，重新加载...")

            # 获取重载前的统计信息
            old_stats = faiss_manager.get_stats()

            if faiss_manager.load_index():
                check_faiss_index_update.last_mtime = current_mtime
                new_stats = faiss_manager.get_stats()

                logger.info("✅ FAISS索引重载成功")
                logger.info(f"  向量数: {old_stats['total_vectors']} -> {new_stats['total_vectors']}")
                logger.info(f"  墓碑数: {old_stats['tombstone_count']} -> {new_stats['tombstone_count']}")
                logger.info(f"  有效向量: {old_stats['effective_vectors']} -> {new_stats['effective_vectors']}")
            else:
                logger.error("❌ FAISS索引重载失败")

    except Exception as e:
        logger.error(f"检查FAISS索引更新失败: {e}", exc_info=True)


@asynccontextmanager
async def lifespan(app: FastAPI):
    """应用生命周期管理"""
    global config, db_manager, search_engine, data_sync, sync_thread, scheduler, faiss_manager

    logger.info("启动 Design Image Search 服务...")

    # 加载配置
    config = load_config()

    # 创建必要的目录
    os.makedirs(config['upload']['temp_dir'], exist_ok=True)
    os.makedirs("./logs", exist_ok=True)

    # 初始化数据库管理器
    db_manager = DatabaseManager(config['database']['sqlite']['path'])
    logger.info("数据库管理器初始化完成")

    # 初始化 FAISS 管理器
    faiss_manager = FAISSManager(
        index_path=config['faiss']['index_path'],
        mapping_path=config['faiss']['mapping_path'],
        tombstone_path=config['faiss']['tombstone_path'],
        vector_dim=config['faiss']['vector_dim']
    )

    # 尝试加载现有索引
    if not faiss_manager.load_index():
        logger.warning("未找到 FAISS 索引，首次搜索前需要运行数据同步")

    # 初始化内存索引
    memory_index = InMemoryIndex()
    if not memory_index.load_from_db(config['database']['sqlite']['path']):
        logger.warning("内存索引加载失败，搜索性能可能受影响")

    # 初始化搜索引擎
    search_engine = ImageSearchEngine(
        db_path=config['database']['sqlite']['path'],
        config=config,
        memory_index=memory_index,
        faiss_manager=faiss_manager
    )

    # 启动后台数据同步线程
    data_sync = DesignDataSync(config, memory_index=memory_index)

    import threading
    def sync_worker():
        try:
            data_sync.run_forever()
        except Exception as e:
            logger.error(f"数据同步线程出错: {e}")

    sync_thread = threading.Thread(target=sync_worker, daemon=True)
    sync_thread.start()
    logger.info("后台数据同步线程已启动")

    # 启动定时任务
    scheduler = BackgroundScheduler()

    # 每天 0:00 和 12:00 执行同步任务
    scheduler.add_job(
        func=scheduled_sync,
        trigger=CronTrigger(hour='0,12', minute='0'),
        id='scheduled_sync',
        replace_existing=True
    )

    # 每分钟检查一次索引更新（data_sync会用os.utime通知我们）
    scheduler.add_job(
        func=check_faiss_index_update,
        trigger=CronTrigger(minute='*/5'),
        id='check_faiss_update',
        replace_existing=True
    )

    scheduler.start()
    logger.info("定时任务已启动（每天 0:00 和 12:00 执行，每5分钟检查FAISS索引更新）")

    logger.info("Design Image Search 服务启动完成")

    yield

    # 清理代码
    logger.info("正在关闭 Design Image Search 服务...")
    if scheduler and scheduler.running:
        scheduler.shutdown()
        logger.info("定时任务已关闭")


# 创建 FastAPI 应用
app = FastAPI(
    title="Design Image Search Service",
    description="Design 图像搜索服务 - 基于图像特征检索相似款式",
    version="1.0.0",
    lifespan=lifespan
)


def verify_token(authorization: str = Header(None)) -> Dict[str, Any]:
    """
    JWT 认证中间件

    Args:
        authorization: Authorization header

    Returns:
        Dict: JWT payload

    Raises:
        HTTPException: 认证失败
    """
    if not authorization:
        raise HTTPException(
            status_code=401,
            detail="Missing authorization header",
            headers={"WWW-Authenticate": "Bearer"}
        )

    if not authorization.startswith("Bearer "):
        raise HTTPException(
            status_code=401,
            detail="Invalid authorization header format",
            headers={"WWW-Authenticate": "Bearer"}
        )

    token = authorization.replace("Bearer ", "")

    try:
        payload = jwt.decode(
            token,
            config['jwt']['secret'],
            algorithms=[config['jwt']['algorithm']]
        )

        # 验证 subject
        if payload.get('sub') != config['jwt']['subject']:
            raise HTTPException(
                status_code=403,
                detail="Invalid service subject"
            )

        # 验证过期时间
        exp = payload.get('exp')
        if exp and datetime.fromtimestamp(exp) < datetime.now():
            raise HTTPException(
                status_code=401,
                detail="Token has expired"
            )

        return payload

    except Exception as e:
        # 处理不同 JWT 库的异常
        error_msg = str(e).lower()
        if 'expired' in error_msg or 'signature' in error_msg:
            raise HTTPException(
                status_code=401,
                detail="Token has expired or invalid signature"
            )
        else:
            raise HTTPException(
                status_code=401,
                detail=f"Invalid token: {str(e)}"
            )




@app.get("/")
async def root():
    """根路径"""
    return {
        "service": "Design Image Search",
        "version": "1.0.0",
        "status": "running",
        "timestamp": datetime.now().isoformat()
    }


@app.get("/health")
async def health_check():
    """健康检查接口"""
    try:
        # 获取数据库统计信息
        db_stats = db_manager.get_stats()

        # 获取 FAISS 索引统计信息
        faiss_stats = search_engine.faiss_manager.get_stats() if search_engine else {}

        # 获取同步状态
        last_sync = db_stats['last_sync_time']
        sync_status = "active" if sync_thread and sync_thread.is_alive() else "inactive"

        # 处理 last_sync_time 的格式
        if last_sync:
            if isinstance(last_sync, str):
                # 如果是字符串，直接使用
                last_sync_str = last_sync
            else:
                # 如果是 datetime 对象，转换为 ISO 格式
                last_sync_str = last_sync.isoformat()
        else:
            last_sync_str = None

        return {
            "status": "healthy",
            "timestamp": datetime.now().isoformat(),
            "database": {
                "total_images": db_stats['total_images'],
                "cnn_features": db_stats['cnn_features'],
                "orb_features": db_stats['orb_features']
            },
            "faiss": {
                "total_vectors": faiss_stats.get('total_vectors', 0),
                "effective_vectors": faiss_stats.get('effective_vectors', 0),
                "tombstone_count": faiss_stats.get('tombstone_count', 0),
                "tombstone_threshold": config.get('faiss', {}).get('tombstone_rebuild_threshold', 1000)
            },
            "sync": {
                "status": sync_status,
                "last_sync": last_sync_str,
                "last_sync_count": db_stats['last_sync_count']
            }
        }

    except Exception as e:
        logger.error(f"健康检查失败: {e}")
        return JSONResponse(
            status_code=500,
            content={
                "status": "unhealthy",
                "error": str(e),
                "timestamp": datetime.now().isoformat()
            }
        )


@app.post("/images/search")
async def search_images(
    file: UploadFile = File(...),
    top_n: int = Form(default=20),
    token: Dict = Depends(verify_token)
):
    """
    图像搜索接口

    Args:
        file: 上传的图片文件
        top_n: 返回结果数量（默认 20）
        token: JWT 认证信息（自动注入）

    Returns:
        Dict: 搜索结果
    """
    # 验证文件格式
    allowed_extensions = config['upload']['allowed_formats']
    file_ext = Path(file.filename).suffix.lower().lstrip('.')
    if file_ext not in allowed_extensions:
        raise HTTPException(
            status_code=400,
            detail=f"Unsupported file format. Allowed: {', '.join(allowed_extensions)}"
        )

    # 验证文件大小
    max_size = config['upload']['max_file_size']
    file_size = 0
    content = await file.read()
    file_size = len(content)

    if file_size > max_size:
        raise HTTPException(
            status_code=400,
            detail=f"File too large. Max size: {max_size // (1024*1024)}MB"
        )

    # 生成临时文件路径
    temp_filename = f"{uuid.uuid4()}.{file_ext}"
    temp_path = os.path.join(config['upload']['temp_dir'], temp_filename)

    try:
        # 保存上传的文件
        with open(temp_path, 'wb') as f:
            f.write(content)

        # 限制 top_n 范围
        top_n = min(max(1, top_n), 100)  # 1-100 之间

        # 执行搜索
        start_time = time.time()
        search_results = search_engine.search(temp_path, top_k=top_n)
        query_time = (time.time() - start_time) * 1000  # 转换为毫秒

        # 调试：打印搜索结果
        logger.info(f"搜索引擎返回 {len(search_results)} 个结果")
        if search_results:
            logger.info(f"第一个结果示例: {search_results[0]}")
        else:
            logger.warning("搜索引擎没有返回任何结果")

        # 格式化结果
        formatted_results = []
        for result in search_results:
            # 从搜索引擎获取 img_id
            img_id = result.get('img_id')
            if not img_id:
                logger.warning(f"Search result missing img_id: {result}")
                continue

            # 从数据库获取详细信息
            with db_manager.get_connection() as conn:
                cursor = conn.execute(
                    "SELECT design_no, image_url FROM images WHERE id = ?",
                    (img_id,)
                )
                row = cursor.fetchone()

                if row:
                    # 从结果中提取 CNN 相似度和 RANSAC 信息
                    details = result.get('details', {})
                    formatted_results.append({
                        "design_id": img_id,
                        "design_no": row['design_no'],
                        "image_url": row['image_url'],
                        "similarity": round(result.get('score', 0), 4),
                        "confidence": result.get('confidence', 'medium'),
                        "details": {
                            "cnn_sim": round(details.get('cnn_sim', 0), 4),
                            "ransac_inliers": result.get('ransac_inliers', 0)
                        }
                    })
                else:
                    logger.warning(f"No database record found for img_id: {img_id}")

        return {
            "results": formatted_results,
            "query_time_ms": round(query_time, 2),
            "total_found": len(formatted_results)
        }

    except Exception as e:
        logger.error(f"搜索失败: {e}")
        raise HTTPException(
            status_code=500,
            detail=f"Search failed: {str(e)}"
        )

    finally:
        # 清理临时文件
        if os.path.exists(temp_path):
            os.remove(temp_path)


@app.post("/sync/trigger")
async def trigger_sync(token: Dict = Depends(verify_token)):
    """
    手动触发同步

    Args:
        token: JWT 认证信息（自动注入）

    Returns:
        Dict: 同步结果
    """
    try:
        logger.info("手动触发数据同步...")
        result = data_sync.sync_once()
        return {
            "message": "Sync completed",
            "result": result
        }
    except Exception as e:
        logger.error(f"手动同步失败: {e}")
        raise HTTPException(
            status_code=500,
            detail=f"Sync failed: {str(e)}"
        )


@app.post("/admin/rebuild-all")
async def rebuild_all(token: Dict = Depends(verify_token)):
    """
    全量重建（临时将 last_sync_time 设为 1970，复用增量同步逻辑）

    Args:
        token: JWT 认证信息（自动注入）

    Returns:
        Dict: 重建结果
    """
    try:
        from datetime import datetime

        logger.info("🔄 手动触发全量重建")

        # 临时保存当前的 last_sync_time
        original_sync_time = db_manager.get_last_sync_time()

        # 临时设置为 1970-01-01（获取所有历史数据）
        db_manager.update_sync_time(datetime(1970, 1, 1), 0)

        try:
            # 调用增量同步（但会处理所有数据）
            result = data_sync.sync_once()

            return {
                "success": True,
                "message": "全量重建完成",
                "result": result
            }
        except Exception as e:
            # 失败时恢复原来的 sync_time
            if original_sync_time:
                db_manager.update_sync_time(original_sync_time, 0)
            raise e

    except Exception as e:
        logger.error(f"❌ 全量重建失败: {e}", exc_info=True)
        raise HTTPException(500, f"重建失败: {str(e)}")


# 配置 CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # 生产环境应该配置具体的域名
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)


if __name__ == "__main__":
    # 加载环境变量
    load_dotenv()

    # 加载配置
    config = load_config()

    # 启动服务
    uvicorn.run(
        app,
        host=config['server']['host'],
        port=config['server']['port'],
        workers=1,  # 由于有共享状态，暂时使用单进程
        log_level="info"
    )