service-finder/backend/app/api/v1/endpoints/providers.py

"""
Provider végpontok – Szolgáltató keresés és gyors felvétel (crowdsourced).
"""

import logging
from typing import Optional, List

from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.db.session import get_db
from app.api.deps import get_current_user
from app.models.identity import User
from app.models.marketplace.service import ExpertiseTag
from app.schemas.provider import (
    ProviderSearchResponse,
    ProviderQuickAddIn,
    ProviderQuickAddResponse,
    ProviderUpdateIn,
    ProviderUpdateResponse,
    ExpertiseCategoryOut,
)
from app.services.provider_service import search_providers, quick_add_provider, update_provider

router = APIRouter()
logger = logging.getLogger(__name__)


@router.get("/categories", response_model=List[ExpertiseCategoryOut])
async def list_expertise_categories(
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """
    Visszaadja az összes expertise kategóriát a frontend dropdown számára.
    """
    try:
        stmt = select(ExpertiseTag).order_by(ExpertiseTag.id)
        result = await db.execute(stmt)
        tags = result.scalars().all()
        return [
            ExpertiseCategoryOut(
                id=t.id,
                key=t.key,
                name_hu=t.name_hu,
                name_en=t.name_en,
                category=t.category,
            )
            for t in tags
        ]
    except Exception as e:
        logger.error(f"Hiba a kategóriák lekérése során: {e}", exc_info=True)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Hiba történt a kategóriák lekérése során.",
        )


@router.get("/search", response_model=ProviderSearchResponse)
async def search_service_providers(
    q: Optional[str] = Query(None, min_length=2, max_length=200, description="Keresőszó"),
    category: Optional[str] = Query(None, max_length=50, description="Kategória szűrő (expertise_tags.key)"),
    city: Optional[str] = Query(None, max_length=100, description="Város szűrő"),
    limit: int = Query(20, ge=1, le=100, description="Találatok száma oldalanként"),
    offset: int = Query(0, ge=0, description="Lapozási offset"),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """
    Szolgáltatók keresése egyesített forrásokból.

    Három forrásból keres:
    - **verified_org**: Verifikált szervezetek (fleet.organizations, org_type='service_provider')
    - **staged_data**: Robotok által gyűjtött adatok (marketplace.service_staging)
    - **crowd_added**: Közösség által hozzáadott adatok (marketplace.service_providers)

    A találatok forrás szerint csoportosítva, lapozva érkeznek.
    """
    try:
        result = await search_providers(
            db=db,
            q=q,
            category=category,
            city=city,
            limit=limit,
            offset=offset,
        )
        return result
    except Exception as e:
        logger.error(f"Hiba a szolgáltató keresés során: {e}", exc_info=True)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Hiba történt a keresés során.",
        )


@router.post("/quick-add", response_model=ProviderQuickAddResponse, status_code=status.HTTP_201_CREATED)
async def quick_add_service_provider(
    data: ProviderQuickAddIn,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """
    Gyors szolgáltató felvétel crowdsourcingból.

    Létrehoz egy új Organization-t (is_verified=False, org_type='service_provider'),
    hozzáköt egy ServiceProfile-t, a megadott kategóriát (expertise_tags),
    létrehoz egy Branch-t a címmel, és a felhasználót beállítja OWNER-nek.

    A szolgáltató 'pending_verification' státuszba kerül, amíg a robotok
    vagy az adminok nem ellenőrzik.
    """
    try:
        result = await quick_add_provider(
            db=db,
            data=data,
            user_id=current_user.id,
        )
        return result
    except ValueError as e:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=str(e),
        )
    except Exception as e:
        logger.error(f"Hiba a gyors szolgáltató felvétel során: {e}", exc_info=True)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Hiba történt a szolgáltató rögzítése során.",
        )


@router.put("/{provider_id}", response_model=ProviderUpdateResponse)
async def update_service_provider(
    provider_id: int,
    data: ProviderUpdateIn,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """
    Meglévő szolgáltató (Organization) adatainak szerkesztése.

    Frissíti a szervezet alapadatait (név, cím) és a kapcsolódó
    ServiceProfile kapcsolati mezőit (telefon, email, weboldal, címkék).
    """
    try:
        result = await update_provider(
            db=db,
            provider_id=provider_id,
            data=data,
            user_id=current_user.id,
        )
        return result
    except ValueError as e:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=str(e),
        )
    except Exception as e:
        logger.error(f"Hiba a szolgáltató frissítése során (id={provider_id}): {e}", exc_info=True)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail="Hiba történt a szolgáltató frissítése során.",
        )