from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from typing import List
from app.models.merchant_order import (
    MerchantOrderDB,
    MerchantOrderCreate,
    MerchantOrderInfo,
    generate_order_id,
    generate_verify_code,
    OrderStatus
)
from app.models.merchant_product import MerchantProductDB
from app.models.database import get_db
from app.api.deps import get_current_user
from app.models.user import UserDB
from app.core.response import success_response, error_response, ResponseModel
from datetime import datetime, timezone

router = APIRouter()

@router.post("", response_model=ResponseModel)
async def create_order(
    order: MerchantOrderCreate,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """创建商家订单"""
    # 检查商品是否存在
    product = db.query(MerchantProductDB).filter(
        MerchantProductDB.id == order.merchant_product_id
    ).first()
    if not product:
        return error_response(code=404, message="商品不存在")
    
    # 生成订单号和核销码
    while True:
        order_id = generate_order_id()
        verify_code = generate_verify_code()
        # 检查是否已存在
        exists = db.query(MerchantOrderDB).filter(
            (MerchantOrderDB.order_id == order_id) |
            (MerchantOrderDB.order_verify_code == verify_code)
        ).first()
        if not exists:
            break
    
    # 创建订单
    db_order = MerchantOrderDB(
        order_id=order_id,
        user_id=current_user.userid,
        merchant_product_id=order.merchant_product_id,
        order_amount=order.order_amount,
        status=OrderStatus.CREATED,  # 创建时状态为已下单
        order_verify_code=verify_code
    )
    db.add(db_order)
    
    try:
        db.commit()
        db.refresh(db_order)
        return success_response(data=MerchantOrderInfo.model_validate(db_order))
    except Exception as e:
        db.rollback()
        return error_response(code=500, message=f"创建订单失败: {str(e)}")

@router.get("/user", response_model=ResponseModel)
async def get_user_orders(
    skip: int = 0,
    limit: int = 20,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """获取用户的订单列表"""
    orders = db.query(MerchantOrderDB).filter(
        MerchantOrderDB.user_id == current_user.userid
    ).order_by(
        MerchantOrderDB.create_time.desc()
    ).offset(skip).limit(limit).all()
    
    return success_response(data=[
        MerchantOrderInfo.model_validate(o) for o in orders
    ])

@router.post("/{order_id}/verify", response_model=ResponseModel)
async def verify_order(
    order_id: str,
    verify_code: str,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """核销订单"""
    order = db.query(MerchantOrderDB).filter(
        MerchantOrderDB.order_id == order_id,
        MerchantOrderDB.order_verify_code == verify_code,
        MerchantOrderDB.verify_time.is_(None)  # 未核销
    ).first()
    
    if not order:
        return error_response(code=404, message="订单不存在或已核销")
    
    # 更新核销时间和核销用户
    order.verify_time = datetime.now(timezone.utc)
    order.verify_user_id = current_user.userid
    order.status = OrderStatus.VERIFIED  # 更新为已核销状态
    
    try:
        db.commit()
        return success_response(
            message="核销成功",
            data=MerchantOrderInfo.model_validate(order)
        )
    except Exception as e:
        db.rollback()
        return error_response(code=500, message=f"核销失败: {str(e)}")

@router.post("/{order_id}/unverify", response_model=ResponseModel)
async def set_order_unverified(
    order_id: str,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """设置订单为未核销状态"""
    order = db.query(MerchantOrderDB).filter(
        MerchantOrderDB.order_id == order_id,
        MerchantOrderDB.status == OrderStatus.CREATED  # 只有已下单状态可以设为未核销
    ).first()
    
    if not order:
        return error_response(code=404, message="订单不存在或状态不正确")
    
    # 更新状态为未核销
    order.status = OrderStatus.UNVERIFIED
    
    try:
        db.commit()
        return success_response(
            message="状态更新成功",
            data=MerchantOrderInfo.model_validate(order)
        )
    except Exception as e:
        db.rollback()
        return error_response(code=500, message=f"状态更新失败: {str(e)}")

@router.post("/{order_id}/refund/apply", response_model=ResponseModel)
async def apply_refund(
    order_id: str,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """申请退款"""
    order = db.query(MerchantOrderDB).filter(
        MerchantOrderDB.order_id == order_id,
        MerchantOrderDB.user_id == current_user.userid,  # 只能申请自己的订单
        MerchantOrderDB.status.in_([OrderStatus.CREATED, OrderStatus.UNVERIFIED])  # 只有未核销的订单可以退款
    ).first()
    
    if not order:
        return error_response(code=404, message="订单不存在或状态不允许退款")
    
    # 更新状态为退款中
    order.status = OrderStatus.REFUNDING
    
    try:
        db.commit()
        return success_response(
            message="退款申请成功",
            data=MerchantOrderInfo.model_validate(order)
        )
    except Exception as e:
        db.rollback()
        return error_response(code=500, message=f"申请退款失败: {str(e)}")

@router.post("/{order_id}/refund/confirm", response_model=ResponseModel)
async def confirm_refund(
    order_id: str,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """确认退款（管理员）"""
    order = db.query(MerchantOrderDB).filter(
        MerchantOrderDB.order_id == order_id,
        MerchantOrderDB.status == OrderStatus.REFUNDING  # 只能确认退款中的订单
    ).first()
    
    if not order:
        return error_response(code=404, message="订单不存在或状态不正确")
    
    # 更新状态为已退款
    order.status = OrderStatus.REFUNDED
    
    try:
        db.commit()
        return success_response(
            message="退款确认成功",
            data=MerchantOrderInfo.model_validate(order)
        )
    except Exception as e:
        db.rollback()
        return error_response(code=500, message=f"确认退款失败: {str(e)}")