from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File, Form
from sqlalchemy.orm import Session
from typing import List, Optional

from database import get_db
from models.product_media import ProductMedia
from models.user import User
from schemas.product import (
    ProductMediaResponse, 
    ProductMediaCreate, 
    ProductMediaUpdate
)
from routers.auth import get_current_user
from routers.product_utils import validate_product_exists, get_company_r2_config, delete_r2_and_local_files

# 导入日志模块
from utils.logger import logger

router = APIRouter()


@router.get("/{product_number}/media", response_model=List[ProductMediaResponse])
async def read_product_media(
    product_number: str,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """获取商品媒体列表"""
    logger.info(f"获取商品媒体列表 - product_number: {product_number}, user: {current_user.username}")
    from routers.auth import is_admin_user
    
    query = db.query(ProductMedia).filter(ProductMedia.product_number == product_number)
    
    if not is_admin_user(current_user):
        query = query.filter(ProductMedia.company_code == current_user.company_code)
    
    media = query.order_by(ProductMedia.sort_order).all()
    logger.info(f"获取商品媒体列表成功 - product_number: {product_number}, 共 {len(media)} 个媒体")
    return media


@router.post("/{product_number}/media", response_model=ProductMediaResponse, status_code=status.HTTP_201_CREATED)
async def create_product_media(
    product_number: str,
    media_type: str = Form(...),
    media_alt: Optional[str] = Form(None),
    is_main: Optional[int] = Form(0),
    sort_order: Optional[int] = Form(0),
    media_url: str = Form(...),
    thumbnail_url: Optional[str] = Form(None),
    media_id: str = Form(...),
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """创建商品媒体（通过素材选择器方式）"""
    logger.info(f"创建商品媒体 - product_number: {product_number}, media_type: {media_type}, user: {current_user.username}")
    product = validate_product_exists(product_number, current_user, db)
    
    media_data = {
        'product_number': product_number,
        'product_id': product.id,
        'company_code': current_user.company_code,
        'media_type': media_type,
        'r2_url': media_url,
        'thumbnail_r2_url': thumbnail_url or media_url,
        'media_id': media_id,
        'media_alt': media_alt or '',
        'is_main': is_main,
        'sort_order': sort_order
    }
    
    media = ProductMedia(**media_data)
    db.add(media)
    db.commit()
    db.refresh(media)
    
    logger.info(f"创建商品媒体成功 - media_id: {media.id}, product_number: {product_number}")
    return media


@router.post("/{product_number}/media/batch", response_model=List[ProductMediaResponse], status_code=status.HTTP_201_CREATED)
async def batch_create_product_media(
    product_number: str,
    media_items: List[dict],
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """批量创建商品媒体"""
    logger.info(f"批量创建商品媒体 - product_number: {product_number}, 数量: {len(media_items)}, user: {current_user.username}")
    product = validate_product_exists(product_number, current_user, db)
    
    created_media = []
    for item in media_items:
        media_data = {
            'product_number': product_number,
            'product_id': product.id,
            'company_code': current_user.company_code,
            'media_type': item.get('media_type', 'image'),
            'r2_url': item.get('media_url'),
            'thumbnail_r2_url': item.get('thumbnail_url') or item.get('media_url'),
            'media_id': item.get('media_id'),
            'media_alt': item.get('media_alt', ''),
            'is_main': item.get('is_main', 0),
            'sort_order': item.get('sort_order', 0)
        }
        
        media = ProductMedia(**media_data)
        db.add(media)
        created_media.append(media)
    
    db.commit()
    for media in created_media:
        db.refresh(media)
    
    logger.info(f"批量创建商品媒体成功 - product_number: {product_number}, 成功创建 {len(created_media)} 个媒体")
    return created_media


@router.put("/media/{media_id}", response_model=ProductMediaResponse)
async def update_product_media(
    media_id: int,
    media_update: ProductMediaUpdate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """更新商品媒体"""
    logger.info(f"更新商品媒体 - media_id: {media_id}, user: {current_user.username}")
    from routers.auth import is_admin_user
    
    query = db.query(ProductMedia).filter(ProductMedia.id == media_id)
    
    if not is_admin_user(current_user):
        query = query.filter(ProductMedia.company_code == current_user.company_code)
    
    media = query.first()
    if media is None:
        logger.error(f"媒体不存在 - media_id: {media_id}")
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Media not found")
    update_data = media_update.model_dump(exclude_unset=True)
    for field, value in update_data.items():
        setattr(media, field, value)
    db.commit()
    db.refresh(media)
    logger.info(f"更新商品媒体成功 - media_id: {media_id}")
    return media


@router.delete("/media/{media_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_product_media(
    media_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """删除商品媒体"""
    logger.info(f"删除商品媒体 - media_id: {media_id}, user: {current_user.username}")
    from routers.auth import is_admin_user
    
    query = db.query(ProductMedia).filter(ProductMedia.id == media_id)
    
    if not is_admin_user(current_user):
        query = query.filter(ProductMedia.company_code == current_user.company_code)
    
    media = query.first()
    if media is None:
        logger.error(f"媒体不存在 - media_id: {media_id}")
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Media not found")
    
    db.delete(media)
    db.commit()
    logger.info(f"删除商品媒体成功 - media_id: {media_id}")
    return None