from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from sqlalchemy import text
from typing import Optional, List
from datetime import datetime, date
import json
import traceback

from ...database import SessionLocal, get_db
from ...auth import get_current_user
from ...models import User

router = APIRouter()

def _execute_raw(db: Session, sql: str, params: dict = None):
    """执行原始SQL的辅助函数"""
    try:
        result = db.execute(text(sql), params or {})
        db.commit()
        return result
    except Exception as e:
        db.rollback()
        raise e

@router.get("/stats")
async def get_promotion_overview(
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """获取推广概览统计"""
    try:
        stats = {
            "total_promotions": 0,
            "active_promotions": 0,
            "total_referrals": 0,
            "total_rewards": 0.0,
            "pending_rewards": 0.0
        }
        
        # 统计推广活动数量
        try:
            result = _execute_raw(db, "SELECT COUNT(*) as cnt FROM promotions")
            row = result.fetchone()
            if row:
                stats["total_promotions"] = row[0]
        except:
            pass
        
        # 统计活跃推广活动
        try:
            result = _execute_raw(db, "SELECT COUNT(*) as cnt FROM promotions WHERE status='active'")
            row = result.fetchone()
            if row:
                stats["active_promotions"] = row[0]
        except:
            pass
        
        return {"code": 0, "data": stats}
    except Exception as e:
        traceback.print_exc()
        return {"code": 0, "data": {}}

@router.get("/promotions")
async def list_promotions(
    status: Optional[str] = Query(None),
    page: int = Query(1),
    page_size: int = Query(20),
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """列出推广活动"""
    try:
        promotions = []
        try:
            result = _execute_raw(db, "SELECT * FROM promotions ORDER BY created_at DESC LIMIT 100")
            rows = result.fetchall()
            for row in rows:
                promotions.append({
                    "id": row[0],
                    "title": row[1],
                    "description": row[2],
                    "reward_type": row[3],
                    "reward_value": float(row[4]) if row[4] else 0,
                    "min_payout": float(row[5]) if row[5] else 0,
                    "start_date": str(row[6]) if row[6] else "",
                    "end_date": str(row[7]) if row[7] else "",
                    "status": row[8],
                    "max_referrals": row[9],
                    "created_by": row[10],
                    "created_at": str(row[11]) if row[11] else ""
                })
        except Exception as e:
            print(f"Error fetching promotions: {e}")
        
        return {
            "code": 0,
            "data": {
                "items": promotions,
                "total": len(promotions),
                "page": page,
                "page_size": page_size
            }
        }
    except Exception as e:
        traceback.print_exc()
        return {"code": 0, "data": {"items": [], "total": 0}}

@router.post("/promotions")
async def create_promotion(
    title: str = Query(...),
    reward_type: str = Query(...),
    reward_value: float = Query(...),
    description: Optional[str] = Query(""),
    min_payout: float = Query(0),
    start_date: Optional[str] = Query(None),
    end_date: Optional[str] = Query(None),
    max_referrals: int = Query(0),
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """创建推广活动"""
    try:
        import uuid
        promo_id = str(uuid.uuid4())
        
        # 使用 user.id 而不是 user.get()
        created_by = user.id if hasattr(user, 'id') else "system"
        
        sql = """INSERT INTO promotions 
                  (id, title, description, reward_type, reward_value, min_payout, 
                   start_date, end_date, status, max_referrals, created_by, created_at)
                  VALUES (:id, :title, :desc, :rtype, :rvalue, :min_pay, 
                          :start, :end, 'active', :max_ref, :created_by, NOW())"""
        
        _execute_raw(db, sql, {
            "id": promo_id,
            "title": title,
            "desc": description,
            "rtype": reward_type,
            "rvalue": reward_value,
            "min_pay": min_payout,
            "start": start_date,
            "end": end_date,
            "max_ref": max_referrals,
            "created_by": created_by
        })
        
        return {"code": 0, "message": "推广活动创建成功", "data": {"id": promo_id}}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=str(e))

@router.put("/promotions/{promo_id}")
async def update_promotion(
    promo_id: str,
    title: Optional[str] = Query(None),
    description: Optional[str] = Query(None),
    reward_type: Optional[str] = Query(None),
    reward_value: Optional[float] = Query(None),
    status: Optional[str] = Query(None),
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """更新推广活动"""
    try:
        updates = []
        params = {"id": promo_id}
        
        if title is not None:
            updates.append("title = :title")
            params["title"] = title
        if description is not None:
            updates.append("description = :desc")
            params["desc"] = description
        if reward_type is not None:
            updates.append("reward_type = :rtype")
            params["rtype"] = reward_type
        if reward_value is not None:
            updates.append("reward_value = :rvalue")
            params["rvalue"] = reward_value
        if status is not None:
            updates.append("status = :status")
            params["status"] = status
        
        if updates:
            sql = f"UPDATE promotions SET {', '.join(updates)} WHERE id = :id"
            _execute_raw(db, sql, params)
        
        return {"code": 0, "message": "更新成功"}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=str(e))

@router.delete("/promotions/{promo_id}")
async def delete_promotion(
    promo_id: str,
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """删除推广活动"""
    try:
        _execute_raw(db, "DELETE FROM promotions WHERE id = :id", {"id": promo_id})
        return {"code": 0, "message": "删除成功"}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=str(e))

@router.post("/promotions/{promo_id}/toggle")
async def toggle_promotion(
    promo_id: str,
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """切换推广活动状态"""
    try:
        result = _execute_raw(db, "SELECT status FROM promotions WHERE id = :id", {"id": promo_id})
        row = result.fetchone()
        if not row:
            raise HTTPException(status_code=404, detail="推广活动不存在")
        
        new_status = "inactive" if row[0] == "active" else "active"
        _execute_raw(db, "UPDATE promotions SET status = :status WHERE id = :id", 
                     {"status": new_status, "id": promo_id})
        
        return {"code": 0, "message": "状态已更新", "data": {"status": new_status}}
    except Exception as e:
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=str(e))

@router.get("/referral-links")
async def get_referral_links(
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """获取分销链接列表"""
    return {"code": 0, "data": {"items": []}}

@router.post("/referral-links/generate")
async def generate_referral_link(
    promotion_id: str = Query(...),
    channel: str = Query("default"),
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """生成分销链接"""
    return {"code": 0, "message": "功能开发中"}

@router.get("/rewards")
async def get_referral_rewards(
    status: Optional[str] = Query(None),
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """获取返佣记录"""
    return {"code": 0, "data": {"items": []}}

@router.post("/rewards/{reward_id}/approve")
async def approve_reward(
    reward_id: str,
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """审核返佣记录"""
    return {"code": 0, "message": "功能开发中"}

@router.get("/leaderboard")
async def get_promotion_leaderboard(
    period: str = Query("all"),
    db: Session = Depends(get_db)
):
    """获取推广排行榜"""
    return {"code": 0, "data": {"items": []}}

@router.get("/my-referrals")
async def get_my_referrals(
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """获取我的推荐链接"""
    return {"code": 0, "data": {"items": []}}

@router.get("/my-rewards")
async def get_my_rewards(
    db: Session = Depends(get_db),
    user = Depends(get_current_user)
):
    """获取我的返佣记录"""
    return {"code": 0, "data": {"items": []}}