from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from typing import List
from app.models.order import (
    ShippingOrderDB, 
    ShippingOrderPackageDB, 
    OrderCreate, 
    OrderInfo,
    OrderPackageInfo,
    generate_order_id,
    OrderPriceCalculateRequest,
    OrderPriceInfo
)
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 app.models.coupon import UserCouponDB, CouponStatus
from datetime import datetime, timezone
from app.core.config import settings

router = APIRouter()

@router.post("/", response_model=ResponseModel)
async def create_shipping_order(
    order: OrderCreate,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """创建配送订单"""
    
    # 生成订单号
    orderid = generate_order_id()
    
    # 计算优惠金额
    coupon_discount = 0
    if order.coupon_id:
        # 查询用户优惠券
        user_coupon = db.query(UserCouponDB).filter(
            UserCouponDB.id == order.coupon_id,
            UserCouponDB.user_id == current_user.userid,
            UserCouponDB.status == CouponStatus.UNUSED,
            UserCouponDB.expire_time > datetime.now(timezone.utc)
        ).first()
        
        if not user_coupon:
            return error_response(code=400, message="优惠券无效或已过期")
        
        coupon_discount = user_coupon.coupon_amount
        # 更新优惠券状态
        user_coupon.status = CouponStatus.USED
    
    # 计算最终金额
    final_amount = max(0, order.original_amount - coupon_discount)
    
    # 创建订单
    db_order = ShippingOrderDB(
        orderid=orderid,
        userid=current_user.userid,
        addressid=order.addressid,
        package_count=order.package_count,
        original_amount=order.original_amount,
        coupon_discount_amount=coupon_discount,
        coupon_id=order.coupon_id,
        final_amount=final_amount
    )
    db.add(db_order)
    
    # 创建订单包裹
    for package in order.packages:
        db_package = ShippingOrderPackageDB(
            orderid=orderid,
            station_id=package.station_id,
            pickup_codes=package.pickup_codes
        )
        db.add(db_package)
    
    try:
        db.commit()
        db.refresh(db_order)
        
        # 查询包裹信息
        packages = db.query(ShippingOrderPackageDB).filter(
            ShippingOrderPackageDB.orderid == orderid
        ).all()
        
        return success_response(
            message="订单创建成功",
            data={
                "order": OrderInfo.model_validate(db_order),
                "packages": [OrderPackageInfo.model_validate(p) for p in packages]
            }
        )
    except Exception as e:
        db.rollback()
        return error_response(code=500, message=f"订单创建失败: {str(e)}")

@router.get("/{orderid}", response_model=ResponseModel)
async def get_order(
    orderid: str,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """获取订单详情"""
    # 查询订单
    order = db.query(ShippingOrderDB).filter(
        ShippingOrderDB.orderid == orderid,
        ShippingOrderDB.userid == current_user.userid
    ).first()
    
    if not order:
        return error_response(code=404, message="订单不存在")
    
    # 查询包裹信息
    packages = db.query(ShippingOrderPackageDB).filter(
        ShippingOrderPackageDB.orderid == orderid
    ).all()
    
    return success_response(data={
        "order": OrderInfo.model_validate(order),
        "packages": [OrderPackageInfo.model_validate(p) for p in packages]
    })

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

@router.post("/calculate-price", response_model=ResponseModel)
async def calculate_order_price(
    request: OrderPriceCalculateRequest,
    db: Session = Depends(get_db),
    current_user: UserDB = Depends(get_current_user)
):
    """计算订单价格"""
    package_count = len(request.packages)
    
    # 计算原始金额
    original_amount = settings.ORDER_BASE_PRICE
    if package_count > settings.ORDER_EXTRA_PACKAGE_THRESHOLD:
        extra_packages = package_count - settings.ORDER_EXTRA_PACKAGE_THRESHOLD
        original_amount += extra_packages * settings.ORDER_EXTRA_PACKAGE_PRICE
    
    # 计算优惠券折扣
    coupon_discount = 0
    used_coupon_id = None
    
    # 查询用户所有可用的优惠券
    available_coupons = db.query(UserCouponDB).filter(
        UserCouponDB.user_id == current_user.userid,
        UserCouponDB.status == CouponStatus.UNUSED
    ).order_by(
        UserCouponDB.coupon_amount.desc()  # 优先使用面额大的优惠券
    ).all()
    
    # 选择最优惠的券
    if available_coupons:
        user_coupon = available_coupons[0]  # 取面额最大的优惠券
        coupon_discount = user_coupon.coupon_amount
        used_coupon_id = user_coupon.id
    
    # 计算最终金额
    final_amount = max(0, original_amount - coupon_discount)
    
    price_info = OrderPriceInfo(
        package_count=package_count,
        original_amount=original_amount,
        coupon_discount_amount=coupon_discount,
        coupon_id=used_coupon_id,
        final_amount=final_amount
    )
    
    return success_response(data=price_info)