from fastapi import APIRouter, Depends
from app.models.database import get_db
from app.api.deps import get_admin_user
from app.models.user import UserDB, UserRole
from app.models.order import ShippingOrderDB, OrderStatus
from app.models.community import CommunityDB, CommunityStatus
from sqlalchemy.orm import Session
from datetime import datetime, timedelta
from app.core.response import success_response, error_response, ResponseModel
from typing import Optional
from app.models.user_auth import UserAuthDB
router = APIRouter()

# 获取基础信息
# 总用户数， 今日新增用户数， 总配送订单数， 今日新增配送订单数
# 小区数量， 今日新增小区数

@router.get("")
async def get_dashboard_info(
    db: Session = Depends(get_db)
):
    # 获取接口包括：
    # 总用户数， 今日新增用户数，昨日新增用户数， 总配送订单数， 今日新增配送订单数，昨日新增配送订单数
    # 小区数量， 今日新增小区数，昨日新增小区数

    # 小区数量
    total_community_count = db.query(CommunityDB).filter(CommunityDB.status == CommunityStatus.OPENING).count()

    # 总用户数
    total_user_count = db.query(UserDB).count()

    # 今日新增用户数
    users = db.query(UserDB).all()
    today_user_count = len([user for user in users if user.create_time.date() == datetime.now().date()])

    # 昨日新增用户数
    yesterday_user_count = len([user for user in users if user.create_time.date() == datetime.now().date() - timedelta(days=1)])

    # 查询已下单用户数
    orders = db.query(ShippingOrderDB).filter(ShippingOrderDB.status != OrderStatus.CANCELLED).all()
    has_order_user_count = len(set([order.userid for order in orders]))
    has_order_completed_user_count = len(set([order.userid for order in orders if order.status == OrderStatus.COMPLETED or order.status == OrderStatus.UNPAID]))
    has_paid_user_count = len(set([order.userid for order in orders if order.status == OrderStatus.COMPLETED and order.final_amount > 0]))
    
    order_count = len(orders)

    # 今日新增配送订单数
    today_order_count = len([order for order in orders if order.create_time.date() == datetime.now().date()])

    # 昨日新增配送订单数
    yesterday_order_count = len([order for order in orders if order.create_time.date() == datetime.now().date() - timedelta(days=1)])

    order_completed_count = len([order for order in orders if order.status == OrderStatus.COMPLETED or order.status == OrderStatus.UNPAID])
    
    #需要支付的订单数量
    need_pay_order_count = len([order for order in orders if order.final_amount > 0])
    order_unpaid_count = len([order for order in orders if order.status == OrderStatus.UNPAID])
    order_pay_count = len([order for order in orders if order.status == OrderStatus.COMPLETED and order.final_amount > 0])
    pay_rate = order_unpaid_count / need_pay_order_count if need_pay_order_count > 0 else 0

    # 已支付的订单数量
    order_amount = sum([order.original_amount_with_additional_fee for order in orders if order.status != OrderStatus.CANCELLED])
    completed_order_amount = sum([order.original_amount_with_additional_fee for order in orders if order.status == OrderStatus.COMPLETED])
    pay_amount = sum([order.final_amount for order in orders if order.status == OrderStatus.COMPLETED and order.final_amount > 0])
    unpaid_amount = sum([order.original_amount_with_additional_fee for order in orders if order.status == OrderStatus.UNPAID])

    # 今日订单金额
    today_order_amount = sum([order.original_amount_with_additional_fee for order in orders if order.create_time.date() == datetime.now().date()])

    # 昨日订单金额
    yesterday_order_amount = sum([order.original_amount_with_additional_fee for order in orders if order.create_time.date() == datetime.now().date() - timedelta(days=1)])

    return success_response(data={
        "total_community_count": total_community_count,
        "total_user_count": total_user_count,
        "has_order_user_count": has_order_user_count,
        "has_order_completed_user_count": has_order_completed_user_count,
        "has_paid_user_count": has_paid_user_count,
        "order_count": order_count,
        "order_completed_count": order_completed_count,
        "order_pay_count": order_pay_count,
        "order_unpaid_count": order_unpaid_count,
        "pay_rate": pay_rate,
        "order_amount": order_amount,
        "pay_amount": pay_amount,
        "unpaid_amount": unpaid_amount,
        "completed_order_amount": completed_order_amount,
        "today_user_count": today_user_count,
        "yesterday_user_count": yesterday_user_count,
        "today_order_count": today_order_count,
        "yesterday_order_count": yesterday_order_count,
        "today_order_amount": today_order_amount,
        "yesterday_order_amount": yesterday_order_amount
    })

@router.get("/deliveryman")
async def get_deliveryman_dashboard_info(
    community_id: Optional[int] = None,
    db: Session = Depends(get_db)
):
    # 获取配送员信息
    query = db.query(UserDB, UserAuthDB.name.label('auth_name')).join(UserAuthDB, UserDB.userid == UserAuthDB.user_id).filter(UserDB.roles.contains(UserRole.DELIVERYMAN))
    if community_id:
        query = query.filter(UserDB.community_id == community_id)
    deliverymans = query.all()
    
    result = []
    for deliveryman in deliverymans:
        orders = db.query(ShippingOrderDB).filter(ShippingOrderDB.deliveryman_user_id == deliveryman.UserDB.userid, ShippingOrderDB.status.in_([OrderStatus.COMPLETED, OrderStatus.UNPAID])).all()
        today_orders = db.query(ShippingOrderDB).filter(ShippingOrderDB.deliveryman_user_id == deliveryman.UserDB.userid, ShippingOrderDB.status.in_([OrderStatus.COMPLETED, OrderStatus.UNPAID]), ShippingOrderDB.completed_time >= datetime.now().date()).all()
        result.append({
            "deliveryman_id": deliveryman.UserDB.userid,
            "deliveryman_name": deliveryman.UserDB.nickname,
            "deliveryman_auth_name": deliveryman.auth_name,
            "deliveryman_community_name": deliveryman.UserDB.community.name,
            "order_count": len(orders),
            "order_amount": sum([order.original_amount_with_additional_fee for order in orders]),
            "today_order_count": len(today_orders),
            "today_order_amount": sum([order.original_amount_with_additional_fee for order in today_orders])
        })

        # 按照今日订单量排序
        result.sort(key=lambda x: x["today_order_count"], reverse=True)
    return success_response(data=result)