"""
卡密管理接口
"""
from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session
from pydantic import BaseModel
import secrets
import string
from app.database import get_db
from app.api.deps import get_current_admin
from app.models.card import Card
from datetime import datetime

router = APIRouter()

class CardGenerateRequest(BaseModel):
    """生成卡密请求"""
    software_code: str
    days: int
    discount: float
    count: int

def generate_card_code() -> str:
    """生成卡密代码"""
    characters = string.ascii_uppercase + string.digits
    return ''.join(secrets.choice(characters) for _ in range(16))

@router.post("/generate")
async def generate_cards(
    req: CardGenerateRequest,
    db: Session = Depends(get_db),
    current_admin = Depends(get_current_admin)
):
    """生成卡密"""
    cards = []
    for _ in range(req.count):
        card_code = generate_card_code()
        # 确保卡密唯一
        while db.query(Card).filter(Card.card_code == card_code).first():
            card_code = generate_card_code()
        
        card = Card(
            card_code=card_code,
            software_code=req.software_code,
            days=req.days,
            discount=req.discount,
            status=0,
            created_at=datetime.now(),
            updated_at=datetime.now()
        )
        db.add(card)
        cards.append(card)
    
    db.commit()
    
    return {
        "code": 200,
        "msg": "生成成功",
        "data": {
            "count": len(cards),
            "cards": [c.card_code for c in cards]
        }
    }

@router.get("")
async def get_cards(
    page: int = Query(1, ge=1),
    page_size: int = Query(10, ge=1, le=100),
    keyword: str = Query(None, description="搜索关键词（卡密代码）"),
    software_code: str = Query(None, description="软件特征码筛选"),
    status: int = Query(None, description="状态筛选：0-未激活，1-已激活，2-已过期"),
    db: Session = Depends(get_db),
    current_admin = Depends(get_current_admin)
):
    """获取卡密列表"""
    from sqlalchemy import or_
    
    offset = (page - 1) * page_size
    
    query = db.query(Card)
    
    # 搜索
    if keyword:
        query = query.filter(Card.card_code.like(f"%{keyword}%"))
    
    # 筛选
    if software_code:
        query = query.filter(Card.software_code == software_code)
    
    if status is not None:
        query = query.filter(Card.status == status)
    
    # 排序
    query = query.order_by(Card.created_at.desc())
    
    cards = query.offset(offset).limit(page_size).all()
    total = query.count()
    
    return {
        "code": 200,
        "msg": "成功",
        "data": [
            {
                "id": c.id,
                "card_code": c.card_code,
                "software_code": c.software_code,
                "days": c.days,
                "discount": float(c.discount),
                "status": c.status,
                "user_id": c.user_id,
                "activated_at": c.activated_at.isoformat() if c.activated_at else None,
                "expire_time": c.expire_time.isoformat() if c.expire_time else None,
                "created_at": c.created_at.isoformat() if c.created_at else None,
                "updated_at": c.updated_at.isoformat() if c.updated_at else None
            }
            for c in cards
        ],
        "total": total,
        "page": page,
        "page_size": page_size
    }

@router.get("/{card_id}")
async def get_card_detail(
    card_id: int,
    db: Session = Depends(get_db),
    current_admin = Depends(get_current_admin)
):
    """获取卡密详情"""
    from app.models.user import User
    
    card = db.query(Card).filter(Card.id == card_id).first()
    if not card:
        return {"code": 404, "msg": "卡密不存在"}
    
    user_info = None
    if card.user_id:
        user = db.query(User).filter(User.id == card.user_id).first()
        if user:
            user_info = {
                "id": user.id,
                "username": user.username,
                "email": user.email,
                "machine_code": user.machine_code,
            }
    
    return {
        "code": 200,
        "msg": "成功",
        "data": {
            "id": card.id,
            "card_code": card.card_code,
            "software_code": card.software_code,
            "days": card.days,
            "discount": float(card.discount),
            "status": card.status,
            "user_id": card.user_id,
            "user_info": user_info,
            "activated_at": card.activated_at.isoformat() if card.activated_at else None,
            "expire_time": card.expire_time.isoformat() if card.expire_time else None,
            "created_at": card.created_at.isoformat() if card.created_at else None,
            "updated_at": card.updated_at.isoformat() if card.updated_at else None
        }
    }

@router.get("/{card_id}/activate")
async def get_card_activate_info(
    card_id: int,
    db: Session = Depends(get_db),
    current_admin = Depends(get_current_admin)
):
    """获取卡密激活信息"""
    card = db.query(Card).filter(Card.id == card_id).first()
    if not card:
        return {"code": 404, "msg": "卡密不存在"}
    
    return {
        "code": 200,
        "msg": "成功",
        "data": {
            "card_code": card.card_code,
            "user_id": card.user_id,
            "activated_at": card.activated_at.isoformat() if card.activated_at else None,
            "expire_time": card.expire_time.isoformat() if card.expire_time else None
        }
    }