from fastapi import APIRouter, Depends, HTTPException, Request
from pydantic import BaseModel, Field
from typing import List, Optional, Dict, Any
from datetime import datetime, timezone
import uuid
import os
import jwt
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials

router = APIRouter(prefix="/clans", tags=["Clans"])

def now_iso():
    return datetime.now(timezone.utc).isoformat()

security = HTTPBearer(auto_error=False)
JWT_SECRET = os.environ.get('JWT_SECRET')

async def get_current_user(request: Request, creds: HTTPAuthorizationCredentials = Depends(security)):
    if not creds:
        return None
    try:
        payload = jwt.decode(creds.credentials, JWT_SECRET, algorithms=["HS256"])
        user_id = payload.get("sub")
        if not user_id: return None
        db = request.app.state.db
        user = await db.users.find_one({"id": user_id})
        return user
    except Exception:
        return None

async def require_auth(user = Depends(get_current_user)):
    if not user:
        raise HTTPException(status_code=401, detail="Not authenticated")
    return user

class CreateClanReq(BaseModel):
    name: str
    tag: str
    description: Optional[str] = ""
    motto: Optional[str] = ""
    logo_url: Optional[str] = ""
    banner_url: Optional[str] = ""
    game_type: Optional[str] = "cs16"
    accent_color: Optional[str] = "#ea580c"
    discord: Optional[str] = ""
    steam: Optional[str] = ""
    is_recruiting: Optional[bool] = True
    is_private: Optional[bool] = False

class UpdateClanReq(BaseModel):
    name: str
    tag: str
    description: Optional[str] = ""
    logo_url: Optional[str] = ""
    banner_url: Optional[str] = ""
    avatar_frame: Optional[str] = ""
    accent_color: Optional[str] = "#ea580c"
    max_members: Optional[int] = 100
    is_recruiting: Optional[bool] = True
    is_private: Optional[bool] = False
    discord: Optional[str] = ""
    steam: Optional[str] = ""
    website: Optional[str] = ""
    motto: Optional[str] = ""

class UpdateRoleReq(BaseModel):
    role: str

class ResolveAppReq(BaseModel):
    action: str

class BuyFrameReq(BaseModel):
    frame_id: str
    price: int

class DepositClanCoinsReq(BaseModel):
    amount: int

class CreateWarChallengeReq(BaseModel):
    opponent_clan_id: str
    game_type: Optional[str] = "cs2"
    map_name: Optional[str] = "de_mirage"
    scheduled_time: Optional[str] = ""
    stake_coins: Optional[int] = 0
    notes: Optional[str] = ""

class ResolveWarReq(BaseModel):
    winner_clan_id: str
    score_home: int
    score_away: int
    mvp_user_id: Optional[str] = None
    mvp_username: Optional[str] = None
    match_proof_url: Optional[str] = ""

class BuyPerkReq(BaseModel):
    perk_id: str

class ClanHQMessageReq(BaseModel):
    message: str

class ClanAnnouncementReq(BaseModel):
    title: str
    content: str
    tag: Optional[str] = "IMPORTANT"

class InviteMemberReq(BaseModel):
    username: str

CLAN_PERKS_CATALOG = [
  {
    "id": "slot_boost_30",
    "name": "Extindere Roster (30 Sloturi)",
    "description": "Mărește capacitatea maximă a clanului la 30 de membri.",
    "price_coins": 500,
    "icon": "Users",
    "category": "Roster",
    "apply_effect": {"max_members": 30}
  },
  {
    "id": "slot_boost_60",
    "name": "Divizie Extinsă (60 Sloturi)",
    "description": "Mărește capacitatea maximă a clanului la 60 de membri.",
    "price_coins": 1200,
    "icon": "Users",
    "category": "Roster",
    "apply_effect": {"max_members": 60}
  },
  {
    "id": "slot_boost_100",
    "name": "Armată Esports (100 Sloturi)",
    "description": "Mărește capacitatea maximă a clanului la 100 de membri.",
    "price_coins": 2500,
    "icon": "Users",
    "category": "Roster",
    "apply_effect": {"max_members": 100}
  },
  {
    "id": "idg_booster_15",
    "name": "IDG Multiplier Booster (+15%)",
    "description": "Toți membrii clanului primesc +15% mai multe IDG Points la activitate pe forum și meciuri.",
    "price_coins": 1500,
    "icon": "Zap",
    "category": "Economie",
    "apply_effect": {"has_idg_booster": True}
  },
  {
    "id": "server_tag_color",
    "name": "Tag VIP Colorat pe Servere",
    "description": "Tag-ul clanului apare automat colorat cu nuanța aleasă pe serverele de CS2 / CS 1.6 din comunitate.",
    "price_coins": 800,
    "icon": "Shield",
    "category": "Cosmetics",
    "apply_effect": {"has_server_tag": True}
  },
  {
    "id": "prestige_badge",
    "name": "Insignă de Prestigiu pe Forum",
    "description": "Emblema și blazonul clanului sunt afișate lângă numele fiecărui membru în topicuri.",
    "price_coins": 1000,
    "icon": "Crown",
    "category": "Cosmetics",
    "apply_effect": {"has_prestige_badge": True}
  }
]

# ===================== STATIC & ADMIN ROUTES =====================

@router.get("/admin/all")
async def get_all_clans_admin(request: Request, user = Depends(require_auth)):
    db = request.app.state.db
    if user.get("role") not in ("admin", "root"):
        raise HTTPException(status_code=403, detail="Admin only")
    clans = await db.idg_clans.find({}).to_list(100)
    for c in clans:
        c["_id"] = str(c["_id"])
        c["member_count"] = await db.idg_clan_members.count_documents({"clan_id": c["id"]})
        c["idg_coins"] = c.get("idg_coins", c.get("pz_coins", 0))
    return {"clans": clans}

@router.delete("/admin/{clan_id}")
async def delete_clan_admin(request: Request, clan_id: str, user = Depends(require_auth)):
    db = request.app.state.db
    if user.get("role") not in ("admin", "root"):
        raise HTTPException(status_code=403, detail="Admin only")
    await db.idg_clans.delete_one({"id": clan_id})
    await db.idg_clan_members.delete_many({"clan_id": clan_id})
    await db.idg_clan_applications.delete_many({"clan_id": clan_id})
    return {"message": "Clan deleted by admin"}

@router.put("/applications/{app_id}")
async def resolve_clan_application(request: Request, app_id: str, req: ResolveAppReq, user = Depends(require_auth)):
    db = request.app.state.db
    app_doc = await db.idg_clan_applications.find_one({"id": app_id})
    if not app_doc:
        raise HTTPException(status_code=404, detail="Application not found")
        
    clan_id = app_doc["clan_id"]
    member = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not member or member["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Only leaders and officers can manage applications")
        
    if req.action == "accept":
        await db.idg_clan_members.insert_one({
            "clan_id": clan_id,
            "user_id": app_doc["user_id"],
            "role": "member",
            "joinedAt": now_iso()
        })
        await db.idg_clan_applications.delete_many({"user_id": app_doc["user_id"]})
        return {"message": "Application accepted and member added"}
    elif req.action == "reject":
        await db.idg_clan_applications.delete_one({"id": app_id})
        return {"message": "Application rejected"}
    else:
        raise HTTPException(status_code=400, detail="Invalid action")

@router.get("/divisions/leaderboard")
async def get_divisions_leaderboard(request: Request):
    db = request.app.state.db
    clans = await db.idg_clans.find({}, {"_id": 0}).sort("xp", -1).to_list(100)
    for i, c in enumerate(clans):
        c["rank"] = i + 1
        c["idg_coins"] = c.get("idg_coins", c.get("pz_coins", 0))
        member_count = await db.idg_clan_members.count_documents({"clan_id": c["id"]})
        c["member_count"] = member_count
        
        if i < 3:
            c["division"] = "PRO"
            c["division_color"] = "#F59E0B"
        elif i < 10:
            c["division"] = "CHALLENGER"
            c["division_color"] = "#38BDF8"
        else:
            c["division"] = "OPEN"
            c["division_color"] = "#94A3B8"
            
    pro_clans = [c for c in clans if c.get("division") == "PRO"]
    challenger_clans = [c for c in clans if c.get("division") == "CHALLENGER"]
    open_clans = [c for c in clans if c.get("division") == "OPEN"]
    
    return {
        "season": "Sezonul 1 (2026)",
        "all_clans": clans,
        "pro": pro_clans,
        "challenger": challenger_clans,
        "open": open_clans
    }

@router.post("/wars/challenge")
async def create_war_challenge(request: Request, req: CreateWarChallengeReq, user = Depends(require_auth)):
    db = request.app.state.db
    membership = await db.idg_clan_members.find_one({"user_id": user["id"]})
    if not membership or membership["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Doar liderul și ofițerii pot trimite provocări de război")
    
    challenger_clan_id = membership["clan_id"]
    if challenger_clan_id == req.opponent_clan_id:
        raise HTTPException(status_code=400, detail="Nu poți provoca propriul clan")
        
    challenger = await db.idg_clans.find_one({"id": challenger_clan_id})
    opponent = await db.idg_clans.find_one({"id": req.opponent_clan_id})
    if not challenger or not opponent:
        raise HTTPException(status_code=404, detail="Clanul nu a fost găsit")
        
    stake = max(0, req.stake_coins or 0)
    challenger_coins = challenger.get("idg_coins", challenger.get("pz_coins", 0))
    if stake > 0 and challenger_coins < stake:
        raise HTTPException(status_code=400, detail=f"Fonduri insuficiente în seif ({challenger_coins} IDG Coins disponibili, necesar {stake})")
        
    war_id = str(uuid.uuid4())
    war_doc = {
        "id": war_id,
        "challenger_clan_id": challenger_clan_id,
        "challenger_name": challenger.get("name"),
        "challenger_tag": challenger.get("tag"),
        "challenger_logo": challenger.get("logo_url"),
        "opponent_clan_id": req.opponent_clan_id,
        "opponent_name": opponent.get("name"),
        "opponent_tag": opponent.get("tag"),
        "opponent_logo": opponent.get("logo_url"),
        "game_type": req.game_type or "cs2",
        "map_name": req.map_name or "de_mirage",
        "scheduled_time": req.scheduled_time or now_iso(),
        "stake_coins": stake,
        "notes": req.notes or "",
        "status": "pending",
        "score_challenger": 0,
        "score_opponent": 0,
        "winner_clan_id": None,
        "mvp_username": None,
        "createdAt": now_iso()
    }
    await db.idg_clan_wars.insert_one(war_doc)
    war_doc.pop("_id", None)
    return war_doc

@router.get("/wars")
async def get_all_wars(request: Request, status: Optional[str] = None, limit: int = 30):
    db = request.app.state.db
    query = {}
    if status:
        query["status"] = status
    wars = await db.idg_clan_wars.find(query, {"_id": 0}).sort("createdAt", -1).limit(limit).to_list(limit)
    return {"wars": wars}

@router.put("/wars/{war_id}/status")
async def update_war_status(request: Request, war_id: str, action: str, user = Depends(require_auth)):
    db = request.app.state.db
    war = await db.idg_clan_wars.find_one({"id": war_id})
    if not war:
        raise HTTPException(status_code=404, detail="Meciul nu a fost găsit")
        
    membership = await db.idg_clan_members.find_one({"user_id": user["id"]})
    if not membership or membership["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Permisiune insuficientă")
        
    my_clan_id = membership["clan_id"]
    if action == "accept":
        if my_clan_id != war["opponent_clan_id"]:
            raise HTTPException(status_code=403, detail="Doar clanul provocat poate accepta meciul")
        await db.idg_clan_wars.update_one({"id": war_id}, {"$set": {"status": "accepted"}})
        return {"message": "Meci acceptat cu succes!"}
    elif action == "decline":
        if my_clan_id != war["opponent_clan_id"]:
            raise HTTPException(status_code=403, detail="Doar clanul provocat poate refuza meciul")
        await db.idg_clan_wars.update_one({"id": war_id}, {"$set": {"status": "declined"}})
        return {"message": "Meci refuzat"}
    elif action == "cancel":
        if my_clan_id != war["challenger_clan_id"]:
            raise HTTPException(status_code=403, detail="Doar inițiatorul poate anula provocarea")
        await db.idg_clan_wars.update_one({"id": war_id}, {"$set": {"status": "cancelled"}})
        return {"message": "Provocare anulată"}
    else:
        raise HTTPException(status_code=400, detail="Acțiune necunoscută")

@router.post("/wars/{war_id}/resolve")
async def resolve_war(request: Request, war_id: str, req: ResolveWarReq, user = Depends(require_auth)):
    db = request.app.state.db
    war = await db.idg_clan_wars.find_one({"id": war_id})
    if not war:
        raise HTTPException(status_code=404, detail="Meciul nu a fost găsit")
    if war.get("status") == "finished":
        raise HTTPException(status_code=400, detail="Meciul este deja finalizat")
        
    membership = await db.idg_clan_members.find_one({"user_id": user["id"]})
    if not membership or membership["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Doar liderul sau ofițerul poate înregistra scorul")
        
    winner_clan_id = req.winner_clan_id
    stake = war.get("stake_coins", 0)
    
    xp_reward = 150
    if winner_clan_id and stake > 0:
        loser_clan_id = war["challenger_clan_id"] if winner_clan_id == war["opponent_clan_id"] else war["opponent_clan_id"]
        await db.idg_clans.update_one({"id": loser_clan_id}, {"$inc": {"idg_coins": -stake, "pz_coins": -stake}})
        await db.idg_clans.update_one({"id": winner_clan_id}, {"$inc": {"idg_coins": stake, "pz_coins": stake, "xp": xp_reward}})
    elif winner_clan_id:
        await db.idg_clans.update_one({"id": winner_clan_id}, {"$inc": {"xp": xp_reward}})
        
    await db.idg_clan_wars.update_one(
        {"id": war_id},
        {"$set": {
            "status": "finished",
            "score_challenger": req.score_home,
            "score_opponent": req.score_away,
            "winner_clan_id": winner_clan_id,
            "mvp_username": req.mvp_username or "",
            "match_proof_url": req.match_proof_url or "",
            "finishedAt": now_iso()
        }}
    )
    return {"message": "Scor înregistrat cu succes!", "xp_awarded": xp_reward}

@router.get("")
async def get_clans(request: Request, search: str = "", skip: int = 0, limit: int = 20):
    db = request.app.state.db
    query = {}
    if search:
        query["$or"] = [
            {"name": {"$regex": search, "$options": "i"}},
            {"tag": {"$regex": search, "$options": "i"}}
        ]
    
    clans_cursor = db.idg_clans.find(query).sort("xp", -1).skip(skip).limit(limit)
    clans = await clans_cursor.to_list(limit)
    
    for clan in clans:
        clan["_id"] = str(clan["_id"])
        member_count = await db.idg_clan_members.count_documents({"clan_id": clan["id"]})
        clan["member_count"] = member_count
        coins = clan.get("idg_coins", clan.get("pz_coins", 0))
        clan["idg_coins"] = coins
        clan["pz_coins"] = coins
        clan["is_private"] = clan.get("is_private", False)
        
    return {"clans": clans}

@router.post("")
async def create_clan(request: Request, req: CreateClanReq, user = Depends(require_auth)):
    db = request.app.state.db
    
    existing_membership = await db.idg_clan_members.find_one({"user_id": user["id"]})
    if existing_membership and user.get("role") not in ("root", "admin"):
        raise HTTPException(status_code=400, detail="You are already in a clan")
        
    if await db.idg_clans.find_one({"name": {"$regex": f"^{req.name}$", "$options": "i"}}):
        raise HTTPException(status_code=400, detail="Clan name already taken")
    if await db.idg_clans.find_one({"tag": {"$regex": f"^{req.tag}$", "$options": "i"}}):
        raise HTTPException(status_code=400, detail="Clan tag already taken")
        
    clan_id = str(uuid.uuid4())
    new_clan = {
        "id": clan_id,
        "name": req.name,
        "tag": req.tag.upper(),
        "motto": req.motto or "",
        "description": req.description,
        "game_type": req.game_type or "cs16",
        "owner_id": user["id"],
        "logo_url": req.logo_url or f"https://ui-avatars.com/api/?background=ff4f00&color=000&bold=true&name={req.tag}",
        "banner_url": req.banner_url or "https://images.unsplash.com/photo-1542751371-adc38448a05e?auto=format&fit=crop&w=800",
        "level": 1,
        "xp": 0,
        "idg_coins": 0,
        "pz_coins": 0,
        "is_vip": False,
        "avatar_frame": "",
        "purchased_frames": [],
        "purchased_perks": [],
        "accent_color": req.accent_color or "#ea580c",
        "max_members": 15,
        "is_recruiting": req.is_recruiting if req.is_recruiting is not None else True,
        "is_private": req.is_private if req.is_private is not None else False,
        "views": 0,
        "likes": [],
        "dislikes": [],
        "rating": 0,
        "social_links": {
            "discord": req.discord or "",
            "steam": req.steam or "",
            "website": ""
        },
        "createdAt": now_iso()
    }
    
    await db.idg_clans.insert_one(new_clan)
    
    await db.idg_clan_members.insert_one({
        "clan_id": clan_id,
        "user_id": user["id"],
        "role": "leader",
        "joinedAt": now_iso()
    })
    
    new_clan["_id"] = str(new_clan["_id"])
    return new_clan

# ===================== PARAMETERIZED CLAN ROUTES =====================

@router.get("/{clan_id}")
async def get_clan(request: Request, clan_id: str):
    db = request.app.state.db
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clan not found")
    clan["_id"] = str(clan["_id"])
    coins = clan.get("idg_coins", clan.get("pz_coins", 0))
    clan["idg_coins"] = coins
    clan["pz_coins"] = coins
    
    # Privacy check: if clan is private, only members and admins can see full details
    requesting_user = None
    is_member = False
    try:
        auth = request.headers.get("Authorization", "")
        if auth.startswith("Bearer "):
            import jwt as _jwt
            payload = _jwt.decode(auth[7:], request.app.state.jwt_secret, algorithms=["HS256"])
            requesting_user = await db.users.find_one({"id": payload["sub"]})
            if requesting_user:
                mem = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": requesting_user["id"]})
                is_member = mem is not None
    except Exception:
        pass
    
    is_admin = requesting_user and requesting_user.get("role") in ("admin", "root")
    
    # Increment views
    await db.idg_clans.update_one({"id": clan_id}, {"$inc": {"views": 1}})
    clan["views"] = clan.get("views", 0) + 1
    
    # Calculate rank
    higher_count = await db.idg_clans.count_documents({"xp": {"$gt": clan.get("xp", 0)}})
    clan["rank"] = higher_count + 1
    
    # Build roster
    members = await db.idg_clan_members.find({"clan_id": clan_id}).to_list(100)
    user_ids = [m["user_id"] for m in members]
    users = await db.users.find({"id": {"$in": user_ids}}).to_list(100)
    
    user_map = {u["id"]: u for u in users}
    
    roster = []
    for m in members:
        u = user_map.get(m["user_id"])
        if u:
            group_color = "#71717A"
            group_name = "Utilizator"
            if u.get("role") == "root":
                group_color = "#EF4444"
                group_name = "ROOT"
            elif u.get("role") == "admin":
                group_color = "#EA580C"
                group_name = "ADMIN"
            elif u.get("role") == "mod":
                group_color = "#3B82F6"
                group_name = "MODERATOR"
            elif u.get("group_name"):
                group_name = u.get("group_name")
                group_color = u.get("group_color", "#A855F7")
                
            roster.append({
                "user_id": u["id"],
                "username": u["username"],
                "avatarUrl": u.get("avatar_url") or f"https://ui-avatars.com/api/?background=random&name={u['username']}",
                "role": m["role"],
                "group_name": group_name,
                "group_color": group_color,
                "message_count": u.get("message_count", 0),
                "topic_count": u.get("topic_count", 0),
                "last_seen": u.get("last_seen"),
                "joined_at": m.get("joinedAt")
            })
            
    role_order = {"leader": 1, "officer": 2, "member": 3}
    roster.sort(key=lambda x: role_order.get(x["role"], 4))
    
    clan["roster"] = roster
    clan["member_count"] = len(roster)
    
    # Privacy flag: if private and not a member or admin, hide confidential vault balance
    if clan.get("is_private") and not is_member and not is_admin:
        clan["confidential_restricted"] = True
        clan["idg_coins"] = None
        clan["pz_coins"] = None
    else:
        clan["confidential_restricted"] = False
    
    return clan

@router.put("/{clan_id}")
async def update_clan(request: Request, clan_id: str, req: UpdateClanReq, user = Depends(require_auth)):
    db = request.app.state.db
    
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clan not found")
        
    member = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not member or member["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Only leaders and officers can edit clan settings")
        
    update_data = {
        "name": req.name,
        "tag": req.tag.upper(),
        "description": req.description,
        "logo_url": req.logo_url,
        "banner_url": req.banner_url,
        "avatar_frame": req.avatar_frame,
        "accent_color": req.accent_color,
        "max_members": req.max_members or 100,
        "is_recruiting": req.is_recruiting,
        "is_private": req.is_private if req.is_private is not None else False,
        "motto": req.motto,
        "social_links": {
            "discord": req.discord or "",
            "steam": req.steam or "",
            "website": req.website or ""
        }
    }
    
    await db.idg_clans.update_one({"id": clan_id}, {"$set": update_data})
    return {"message": "Clan updated successfully"}

@router.post("/{clan_id}/like")
async def like_clan(request: Request, clan_id: str, user = Depends(require_auth)):
    db = request.app.state.db
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clan not found")
        
    likes = set(clan.get("likes", []))
    dislikes = set(clan.get("dislikes", []))
    dislike_timestamps = clan.get("dislike_timestamps", {})
    
    if user["id"] in likes:
        likes.remove(user["id"])
    else:
        likes.add(user["id"])
        if user["id"] in dislikes:
            dislikes.remove(user["id"])
            dislike_timestamps.pop(user["id"], None)
            
    rating = len(likes) - len(dislikes)
    await db.idg_clans.update_one(
        {"id": clan_id}, 
        {"$set": {"likes": list(likes), "dislikes": list(dislikes), "rating": rating, "dislike_timestamps": dislike_timestamps}}
    )
    return {"likes": len(likes), "dislikes": len(dislikes), "rating": rating}

@router.post("/{clan_id}/dislike")
async def dislike_clan(request: Request, clan_id: str, user = Depends(require_auth)):
    db = request.app.state.db
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clan not found")
        
    likes = clan.get("likes", [])
    dislikes = clan.get("dislikes", [])
    dislike_timestamps = clan.get("dislike_timestamps", {})
    
    now = datetime.now(timezone.utc)
    
    if user["id"] in dislikes:
        last_dislike = dislike_timestamps.get(user["id"])
        if last_dislike:
            last_dt = datetime.fromisoformat(last_dislike)
            if (now - last_dt).total_seconds() < 86400:
                raise HTTPException(status_code=400, detail="Nu poți anula dislike-ul mai devreme de 24 ore")
        dislikes.remove(user["id"])
        dislike_timestamps.pop(user["id"], None)
    else:
        dislikes.append(user["id"])
        dislike_timestamps[user["id"]] = now_iso()
        if user["id"] in likes:
            likes.remove(user["id"])
            
    rating = len(likes) - len(dislikes)
    await db.idg_clans.update_one(
        {"id": clan_id}, 
        {"$set": {"likes": likes, "dislikes": dislikes, "rating": rating, "dislike_timestamps": dislike_timestamps}}
    )
    return {"likes": len(likes), "dislikes": len(dislikes), "rating": rating}

@router.post("/{clan_id}/buy-frame")
async def buy_clan_frame(request: Request, clan_id: str, req: BuyFrameReq, user = Depends(require_auth)):
    db = request.app.state.db
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clan not found")
        
    member = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not member or member["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Doar liderul și co-liderii pot achiziționa rame pentru clan")
        
    current_coins = clan.get("idg_coins", clan.get("pz_coins", 0))
    if current_coins < req.price:
        raise HTTPException(status_code=400, detail="Fonduri IDG Coins insuficiente în banca clanului")
        
    purchased = clan.get("purchased_frames", [])
    if req.frame_id in purchased:
        raise HTTPException(status_code=400, detail="Rama este deja achiziționată")
        
    purchased.append(req.frame_id)
    
    await db.idg_clans.update_one(
        {"id": clan_id},
        {
            "$inc": {"idg_coins": -req.price, "pz_coins": -req.price},
            "$set": {"purchased_frames": purchased}
        }
    )
    return {"message": "Ramă achiziționată cu succes!", "idg_coins": current_coins - req.price, "pz_coins": current_coins - req.price}

@router.post("/{clan_id}/deposit")
async def deposit_clan_coins(request: Request, clan_id: str, req: DepositClanCoinsReq, user = Depends(require_auth)):
    if req.amount <= 0:
        raise HTTPException(status_code=400, detail="Suma donată trebuie să fie mai mare de 0")
    db = request.app.state.db
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clanul nu a fost găsit")
    
    user_doc = await db.users.find_one({"id": user["id"]})
    user_points = user_doc.get("points", 0) if user_doc else 0
    if user_points < req.amount:
        raise HTTPException(status_code=400, detail=f"Puncte IDG insuficiente. Ai {user_points} IDG, necesar {req.amount}")
    
    await db.users.update_one({"id": user["id"]}, {"$inc": {"points": -req.amount}})
    
    xp_gain = max(1, req.amount // 2)
    await db.idg_clans.update_one(
        {"id": clan_id}, 
        {"$inc": {"idg_coins": req.amount, "pz_coins": req.amount, "xp": xp_gain}}
    )
    
    await db.points_log.insert_one({
        "id": str(uuid.uuid4()),
        "user_id": user["id"],
        "amount": -req.amount,
        "reason": f"Donație în banca clanului {clan.get('name')}",
        "created_at": now_iso(),
        "month_key": datetime.now(timezone.utc).strftime("%Y-%m")
    })
    
    updated_clan = await db.idg_clans.find_one({"id": clan_id})
    new_clan_coins = updated_clan.get("idg_coins", updated_clan.get("pz_coins", 0))
    user_remaining = user_points - req.amount
    
    return {
        "message": f"Ai depus cu succes {req.amount} IDG Coins în seiful clanului!",
        "clan_idg_coins": new_clan_coins,
        "user_remaining_points": user_remaining,
        "xp_awarded": xp_gain
    }

@router.get("/{clan_id}/wars")
async def get_clan_wars(request: Request, clan_id: str):
    db = request.app.state.db
    query = {"$or": [{"challenger_clan_id": clan_id}, {"opponent_clan_id": clan_id}]}
    wars = await db.idg_clan_wars.find(query, {"_id": 0}).sort("createdAt", -1).to_list(50)
    
    wins = sum(1 for w in wars if w.get("status") == "finished" and w.get("winner_clan_id") == clan_id)
    losses = sum(1 for w in wars if w.get("status") == "finished" and w.get("winner_clan_id") and w.get("winner_clan_id") != clan_id)
    draws = sum(1 for w in wars if w.get("status") == "finished" and not w.get("winner_clan_id"))
    total_finished = wins + losses + draws
    win_rate = round((wins / total_finished * 100), 1) if total_finished > 0 else 0
    
    return {
        "wars": wars,
        "stats": {
            "total": len(wars),
            "finished": total_finished,
            "wins": wins,
            "losses": losses,
            "draws": draws,
            "win_rate": win_rate
        }
    }

@router.get("/{clan_id}/perks")
async def get_clan_perks(request: Request, clan_id: str):
    db = request.app.state.db
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clan not found")
        
    purchased_perks = clan.get("purchased_perks", [])
    perks_with_status = []
    for perk in CLAN_PERKS_CATALOG:
        is_unlocked = perk["id"] in purchased_perks
        if perk["id"] == "slot_boost_30" and clan.get("max_members", 0) >= 30: is_unlocked = True
        if perk["id"] == "slot_boost_60" and clan.get("max_members", 0) >= 60: is_unlocked = True
        if perk["id"] == "slot_boost_100" and clan.get("max_members", 0) >= 100: is_unlocked = True
        perks_with_status.append({**perk, "is_unlocked": is_unlocked})
        
    return {
        "perks": perks_with_status,
        "clan_coins": clan.get("idg_coins", clan.get("pz_coins", 0)),
        "max_members": clan.get("max_members", 15)
    }

@router.post("/{clan_id}/perks/buy")
async def buy_clan_perk(request: Request, clan_id: str, req: BuyPerkReq, user = Depends(require_auth)):
    db = request.app.state.db
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clan not found")
        
    membership = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not membership or membership["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Doar liderul și ofițerii pot debloca perks")
        
    perk = next((p for p in CLAN_PERKS_CATALOG if p["id"] == req.perk_id), None)
    if not perk:
        raise HTTPException(status_code=404, detail="Perk-ul nu există")
        
    current_coins = clan.get("idg_coins", clan.get("pz_coins", 0))
    if current_coins < perk["price_coins"]:
        raise HTTPException(status_code=400, detail=f"Fonduri insuficiente în seif ({current_coins} IDG Coins, necesar {perk['price_coins']})")
        
    purchased = clan.get("purchased_perks", [])
    if req.perk_id in purchased:
        raise HTTPException(status_code=400, detail="Acest perk este deja activat")
        
    purchased.append(req.perk_id)
    update_doc = {
        "$inc": {"idg_coins": -perk["price_coins"], "pz_coins": -perk["price_coins"]},
        "$set": {"purchased_perks": purchased}
    }
    for k, v in perk.get("apply_effect", {}).items():
        update_doc["$set"][k] = v
        
    await db.idg_clans.update_one({"id": clan_id}, update_doc)
    return {
        "message": f"🎉 Felicitări! Perk-ul '{perk['name']}' a fost deblocat!",
        "new_clan_coins": current_coins - perk["price_coins"]
    }

@router.get("/{clan_id}/quests")
async def get_clan_quests(request: Request, clan_id: str):
    db = request.app.state.db
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clan not found")
        
    member_count = await db.idg_clan_members.count_documents({"clan_id": clan_id})
    wars_won = await db.idg_clan_wars.count_documents({"winner_clan_id": clan_id, "status": "finished"})
    claimed_quests = clan.get("claimed_quests", [])
    
    quests = [
        {
            "id": "quest_members_10",
            "title": "Recrutare Activă",
            "description": "Adună cel puțin 5 membri activi în echipa ta.",
            "target": 5,
            "current": member_count,
            "progress_percent": min(100, int((member_count / 5) * 100)),
            "reward_coins": 250,
            "reward_xp": 100,
            "completed": member_count >= 5,
            "claimed": "quest_members_10" in claimed_quests
        },
        {
            "id": "quest_wars_1",
            "title": "Botezul Luptei",
            "description": "Câștigă primul tău meci oficial de Clan War în arenă.",
            "target": 1,
            "current": wars_won,
            "progress_percent": min(100, int((wars_won / 1) * 100)),
            "reward_coins": 400,
            "reward_xp": 150,
            "completed": wars_won >= 1,
            "claimed": "quest_wars_1" in claimed_quests
        },
        {
            "id": "quest_bank_500",
            "title": "Fondul Echipei",
            "description": "Acumulează cel puțin 500 IDG Coins în seiful clanului.",
            "target": 500,
            "current": clan.get("idg_coins", clan.get("pz_coins", 0)),
            "progress_percent": min(100, int((clan.get("idg_coins", clan.get("pz_coins", 0)) / 500) * 100)),
            "reward_coins": 300,
            "reward_xp": 200,
            "completed": clan.get("idg_coins", clan.get("pz_coins", 0)) >= 500,
            "claimed": "quest_bank_500" in claimed_quests
        }
    ]
    return {"quests": quests}

@router.post("/{clan_id}/quests/{quest_id}/claim")
async def claim_clan_quest(request: Request, clan_id: str, quest_id: str, user = Depends(require_auth)):
    db = request.app.state.db
    membership = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not membership or membership["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Doar liderul și ofițerii pot revendica recompensele de clan")
        
    clan = await db.idg_clans.find_one({"id": clan_id})
    claimed = clan.get("claimed_quests", [])
    if quest_id in claimed:
        raise HTTPException(status_code=400, detail="Recompensa a fost deja revendicată")
        
    claimed.append(quest_id)
    rewards = {
        "quest_members_10": (250, 100),
        "quest_wars_1": (400, 150),
        "quest_bank_500": (300, 200)
    }
    coins_add, xp_add = rewards.get(quest_id, (100, 50))
    await db.idg_clans.update_one(
        {"id": clan_id},
        {
            "$inc": {"idg_coins": coins_add, "pz_coins": coins_add, "xp": xp_add},
            "$set": {"claimed_quests": claimed}
        }
    )
    return {"message": f"🎉 Recompensă revendicată: +{coins_add} IDG Coins & +{xp_add} Clan XP!"}

@router.get("/{clan_id}/hq/messages")
async def get_clan_hq_messages(request: Request, clan_id: str, user = Depends(require_auth)):
    db = request.app.state.db
    membership = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not membership and user.get("role") not in ("admin", "root"):
        raise HTTPException(status_code=403, detail="Acces exclusiv membrilor clanului")
        
    messages = await db.idg_clan_hq_messages.find({"clan_id": clan_id}, {"_id": 0}).sort("createdAt", 1).limit(50).to_list(50)
    return {"messages": messages}

@router.post("/{clan_id}/hq/messages")
async def post_clan_hq_message(request: Request, clan_id: str, req: ClanHQMessageReq, user = Depends(require_auth)):
    db = request.app.state.db
    membership = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not membership and user.get("role") not in ("admin", "root"):
        raise HTTPException(status_code=403, detail="Acces exclusiv membrilor clanului")
        
    msg_id = str(uuid.uuid4())
    msg_doc = {
        "id": msg_id,
        "clan_id": clan_id,
        "user_id": user["id"],
        "username": user["username"],
        "avatar_url": user.get("avatar_url") or f"https://ui-avatars.com/api/?background=random&name={user['username']}",
        "role": membership.get("role", "member") if membership else "admin",
        "message": req.message.strip(),
        "createdAt": now_iso()
    }
    await db.idg_clan_hq_messages.insert_one(msg_doc)
    msg_doc.pop("_id", None)
    return msg_doc

@router.get("/{clan_id}/hq/announcements")
async def get_clan_announcements(request: Request, clan_id: str):
    db = request.app.state.db
    clan = await db.idg_clans.find_one({"id": clan_id})
    if clan and clan.get("is_private"):
        auth = request.headers.get("Authorization", "")
        is_allowed = False
        if auth.startswith("Bearer "):
            try:
                import jwt as _jwt
                payload = _jwt.decode(auth[7:], request.app.state.jwt_secret, algorithms=["HS256"])
                user = await db.users.find_one({"id": payload["sub"]})
                if user:
                    if user.get("role") in ("admin", "root"):
                        is_allowed = True
                    else:
                        mem = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
                        if mem:
                            is_allowed = True
            except Exception:
                pass
        if not is_allowed:
            raise HTTPException(status_code=403, detail="Anunțurile sunt confidențiale pentru acest clan privat")

    announcements = await db.idg_clan_announcements.find({"clan_id": clan_id}, {"_id": 0}).sort("createdAt", -1).to_list(20)
    return {"announcements": announcements}

@router.post("/{clan_id}/hq/announcements")
async def create_clan_announcement(request: Request, clan_id: str, req: ClanAnnouncementReq, user = Depends(require_auth)):
    db = request.app.state.db
    membership = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not membership or membership["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Doar conducerea clanului poate posta anunțuri")
        
    ann_id = str(uuid.uuid4())
    ann_doc = {
        "id": ann_id,
        "clan_id": clan_id,
        "author_id": user["id"],
        "author_username": user["username"],
        "title": req.title,
        "content": req.content,
        "tag": req.tag or "IMPORTANT",
        "createdAt": now_iso()
    }
    await db.idg_clan_announcements.insert_one(ann_doc)
    ann_doc.pop("_id", None)
    return ann_doc

@router.delete("/{clan_id}/hq/announcements/{ann_id}")
async def delete_clan_announcement(request: Request, clan_id: str, ann_id: str, user = Depends(require_auth)):
    db = request.app.state.db
    membership = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not membership or membership["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Permisiune insuficientă")
    await db.idg_clan_announcements.delete_one({"id": ann_id, "clan_id": clan_id})
    return {"message": "Anunț șters"}

@router.post("/{clan_id}/apply")
async def apply_clan(request: Request, clan_id: str, user = Depends(require_auth)):
    db = request.app.state.db
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clan not found")
        
    existing_membership = await db.idg_clan_members.find_one({"user_id": user["id"]})
    if existing_membership and user.get("role") not in ("root", "admin"):
        raise HTTPException(status_code=400, detail="You are already in a clan")
        
    existing_app = await db.idg_clan_applications.find_one({"clan_id": clan_id, "user_id": user["id"], "status": "pending"})
    if existing_app:
        raise HTTPException(status_code=400, detail="Application already pending")
        
    app_id = str(uuid.uuid4())
    await db.idg_clan_applications.insert_one({
        "id": app_id,
        "clan_id": clan_id,
        "user_id": user["id"],
        "status": "pending",
        "createdAt": now_iso()
    })
    
    return {"message": "Application submitted successfully", "id": app_id}

@router.post("/{clan_id}/invite")
async def invite_member(request: Request, clan_id: str, req: InviteMemberReq, user = Depends(require_auth)):
    db = request.app.state.db
    actor = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not actor or actor["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Doar liderul și ofițerii pot trimite invitații")
        
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clanul nu a fost găsit")
        
    target_user = await db.users.find_one({"username_lower": req.username.strip().lower()})
    if not target_user:
        target_user = await db.users.find_one({"username": {"$regex": f"^{req.username.strip()}$", "$options": "i"}})
        
    if not target_user:
        raise HTTPException(status_code=404, detail=f"Utilizatorul '{req.username}' nu a fost găsit")
        
    # Check if target is already in a clan
    existing_membership = await db.idg_clan_members.find_one({"user_id": target_user["id"]})
    if existing_membership:
        if existing_membership["clan_id"] == clan_id:
            raise HTTPException(status_code=400, detail="Utilizatorul este deja membru în acest clan")
        else:
            raise HTTPException(status_code=400, detail="Utilizatorul face deja parte din alt clan")
            
    # Add directly as member
    await db.idg_clan_members.insert_one({
        "clan_id": clan_id,
        "user_id": target_user["id"],
        "role": "member",
        "joinedAt": now_iso()
    })
    
    return {"message": f"Utilizatorul {target_user['username']} a fost adăugat cu succes în clan!"}

@router.get("/{clan_id}/applications")
async def get_clan_applications(request: Request, clan_id: str, user = Depends(require_auth)):
    db = request.app.state.db
    member = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not member or member["role"] not in ["leader", "officer"]:
        raise HTTPException(status_code=403, detail="Only leaders and officers can view applications")
        
    apps = await db.idg_clan_applications.find({"clan_id": clan_id, "status": "pending"}).to_list(100)
    for a in apps:
        a["_id"] = str(a["_id"])
        applicant = await db.users.find_one({"id": a["user_id"]})
        if applicant:
            a["username"] = applicant["username"]
            a["avatarUrl"] = applicant.get("avatar_url") or f"https://ui-avatars.com/api/?background=random&name={applicant['username']}"
    return {"applications": apps}

@router.put("/{clan_id}/role/{target_user_id}")
async def update_member_role(request: Request, clan_id: str, target_user_id: str, req: UpdateRoleReq, user = Depends(require_auth)):
    db = request.app.state.db
    
    actor_member = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not actor_member or actor_member["role"] != "leader":
        raise HTTPException(status_code=403, detail="Only the clan leader can change member roles")
        
    target_member = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": target_user_id})
    if not target_member:
        raise HTTPException(status_code=404, detail="Member not found in this clan")
    
    if req.role == "leader":
        await db.idg_clan_members.update_one(
            {"clan_id": clan_id, "user_id": user["id"]},
            {"$set": {"role": "officer"}}
        )
        await db.idg_clan_members.update_one(
            {"clan_id": clan_id, "user_id": target_user_id},
            {"$set": {"role": "leader"}}
        )
        await db.idg_clans.update_one({"id": clan_id}, {"$set": {"owner_id": target_user_id}})
        return {"message": "Leadership transferred successfully"}
    elif req.role in ["officer", "member"]:
        await db.idg_clan_members.update_one(
            {"clan_id": clan_id, "user_id": target_user_id},
            {"$set": {"role": req.role}}
        )
        return {"message": f"Role changed to {req.role}"}
    else:
        raise HTTPException(status_code=400, detail="Invalid role. Use: leader, officer, member")

@router.delete("/{clan_id}/members/{target_user_id}")
async def leave_or_kick_clan(request: Request, clan_id: str, target_user_id: str, user = Depends(require_auth)):
    db = request.app.state.db
    
    membership = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": target_user_id})
    if not membership:
        raise HTTPException(status_code=404, detail="Member not in this clan")
        
    if user["id"] != target_user_id:
        actor_membership = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
        if not actor_membership or actor_membership["role"] not in ["leader", "officer"]:
            raise HTTPException(status_code=403, detail="Not authorized to kick members")
        if membership["role"] == "leader":
            raise HTTPException(status_code=403, detail="Cannot kick the leader")
    else:
        if membership["role"] == "leader":
            other_members = await db.idg_clan_members.count_documents({"clan_id": clan_id})
            if other_members > 1:
                raise HTTPException(status_code=400, detail="Leader must transfer ownership before leaving")
            else:
                await db.idg_clans.delete_one({"id": clan_id})
                
    await db.idg_clan_members.delete_one({"_id": membership["_id"]})
    return {"message": "Success"}

@router.delete("/{clan_id}/disband")
async def disband_clan(request: Request, clan_id: str, user = Depends(require_auth)):
    db = request.app.state.db
    clan = await db.idg_clans.find_one({"id": clan_id})
    if not clan:
        raise HTTPException(status_code=404, detail="Clan not found")
    member = await db.idg_clan_members.find_one({"clan_id": clan_id, "user_id": user["id"]})
    if not member or member["role"] != "leader":
        raise HTTPException(status_code=403, detail="Only the leader can disband the clan")
    await db.idg_clans.delete_one({"id": clan_id})
    await db.idg_clan_members.delete_many({"clan_id": clan_id})
    await db.idg_clan_applications.delete_many({"clan_id": clan_id})
    return {"message": "Clan disbanded successfully"}