from fastapi import APIRouter, Depends, Form, Query, HTTPException, status
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, and_, text
from typing import List, Optional
from app.db.session import get_db
from app.services.gamification_service import GamificationService
from app.models.service import ServiceProfile, ExpertiseTag, ServiceExpertise
from app.services.marketplace_service import (
    create_verified_review,
    get_service_reviews,
    can_user_review_service
)
from app.schemas.social import ServiceReviewCreate, ServiceReviewResponse
from app.api.deps import get_current_user
from app.models.identity import User

router = APIRouter()

# --- 🎯 SZERVIZ VADÁSZAT (Service Hunt) ---
@router.post("/hunt")
async def register_service_hunt(
    name: str = Form(...), 
    lat: float = Form(...), 
    lng: float = Form(...), 
    db: AsyncSession = Depends(get_db)
):
    """ Új szerviz-jelölt rögzítése a staging táblába jutalompontért. """
    # Új szerviz-jelölt rögzítése
    await db.execute(text("""
        INSERT INTO marketplace.service_staging (name, fingerprint, status, raw_data)
        VALUES (:n, :f, 'pending', jsonb_build_object('lat', :lat, 'lng', :lng))
    """), {"n": name, "f": f"{name}-{lat}-{lng}", "lat": lat, "lng": lng})
    
    # MB 2.0 Gamification: 50 pont a felfedezésért
    # TODO: A 1-es ID helyett a bejelentkezett felhasználót kell használni (current_user.id)
    await GamificationService.award_points(db, 1, 50, f"Service Hunt: {name}")
    await db.commit()
    return {"status": "success", "message": "Discovery registered and points awarded."}

# --- 🔍 SZERVIZ KERESŐ (Service Search) ---
@router.get("/search")
async def search_services(
    expertise_key: Optional[str] = Query(None, description="Szakmai címke (pl. brake_service)"),
    city: Optional[str] = Query(None, description="Város szűrés"),
    min_confidence: int = Query(0, description="Minimum hitelességi szint (0-2)"),
    db: AsyncSession = Depends(get_db)
):
    """ Szakmai szempontú keresőmotor, ami a validált címkék alapján szűr. """
    # Alap lekérdezés: Szervizek, akiknek van szakértelmük
    query = select(ServiceProfile).join(ServiceProfile.expertises).join(ServiceExpertise.tag)
    
    filters = []
    if expertise_key:
        filters.append(ExpertiseTag.key == expertise_key)
    if city:
        filters.append(ServiceProfile.city.ilike(f"%{city}%"))
    if min_confidence > 0:
        filters.append(ServiceExpertise.confidence_level >= min_confidence)
        
    if filters:
        query = query.where(and_(*filters))
    
    result = await db.execute(query.distinct())
    services = result.scalars().all()
    
    return services


# --- ⭐ VERIFIED SERVICE REVIEWS (Social 3 - #66) ---

@router.post("/{service_id}/reviews", response_model=ServiceReviewResponse, status_code=status.HTTP_201_CREATED)
async def create_service_review(
    service_id: int,
    review_data: ServiceReviewCreate,
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """
    Verifikált szerviz értékelés beküldése.
    Csak igazolt pénzügyi tranzakció után lehetséges (transaction_id kötelező).
    """
    try:
        review = await create_verified_review(
            db=db,
            service_id=service_id,
            user_id=current_user.id,
            transaction_id=review_data.transaction_id,
            review_data=review_data
        )
        return review
    except ValueError as e:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
    except IntegrityError as e:
        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(e))


@router.get("/{service_id}/reviews", response_model=dict)
async def list_service_reviews(
    service_id: int,
    skip: int = Query(0, ge=0),
    limit: int = Query(20, ge=1, le=100),
    verified_only: bool = Query(True),
    db: AsyncSession = Depends(get_db)
):
    """
    Szerviz értékeléseinek lapozható listázása.
    """
    reviews, total = await get_service_reviews(
        db=db,
        service_id=service_id,
        skip=skip,
        limit=limit,
        verified_only=verified_only
    )
    return {
        "reviews": reviews,
        "total": total,
        "skip": skip,
        "limit": limit
    }


@router.get("/{service_id}/reviews/check")
async def check_review_eligibility(
    service_id: int,
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """
    Ellenőrzi, hogy a felhasználó értékelheti‑e a szervizt.
    """
    can_review, reason = await can_user_review_service(db, current_user.id, service_id)
    return {
        "can_review": can_review,
        "reason": reason,
        "user_id": current_user.id,
        "service_id": service_id
    }