import json
from datetime import datetime
from typing import Optional, List

from fastapi import APIRouter, Depends, Query, HTTPException, Request, Path, Body, BackgroundTasks
from fastapi.responses import Response
from pyasn1.type.univ import Boolean
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, desc, func
from sqlalchemy.orm import selectinload
from sqlalchemy.util import await_only
import os

from src.database import get_db
from src.product.models import Product, ProductCategory
from src.public.schemas import ReviewOut, ManufacturerOut, StoreOut, ProductOut, ResponseWrapper, ProductImageOut, ResponseWrapperStore, CustomerOut, ProductCategoryOut, ProductAttributeOut, ProductReviewCreate, ServiceReviewCreate, ManufacturerReviewCreate, StoreReviewCreate, ResponseWrapperStoreTop, ReviewResponseCreate
from src.public.service import ServicePublic, ReviewResponseService
from src.store.models import Store
from src.manufacturer.models import Manufacturer
from src.review.models import ProductReview, StoreReview, ManufacturerReview, ServiceReview, ReviewStatusEnum
from src.manufacturer.service import ManufacturerService
from src.manufacturer.schemas import ManufacturerListResponse, ManufacturerPhotoResponse
from src.user.dependencies import decode_token, decode_token_optional

router = APIRouter(prefix="/public", tags=["Public Endpoints"])


@router.get("/specialProduct", response_model=ResponseWrapper)
async def get_promo_products():
    from src.main import PRODUCTS_CACHE

    products = [
        p for p in PRODUCTS_CACHE.values()
        if p.get("price_old") and p.get("price_old") > 0
    ][:12]

    return {"status": True, "data": products}


@router.get("/topStore", response_model=ResponseWrapperStoreTop)
async def get_top_stores(db: AsyncSession = Depends(get_db)):
    # Отримуємо кількість відгуків для кожного магазину
    store_reviews_query = await db.execute(
        select(
            StoreReview.store_id,
            func.count(StoreReview.store_review_id).label('reviews_count')
        )
        .where(StoreReview.status == ReviewStatusEnum.approved)
        .group_by(StoreReview.store_id)
    )
    store_reviews_counts = {row.store_id: row.reviews_count for row in store_reviews_query}

    result = await db.execute(
        select(Store)
        .options(
            selectinload(Store.photos),
            selectinload(Store.addresses)
        )
        .order_by(Store.viewed.desc())
    )
    stores = result.scalars().all()

    data = []
    for s in stores:
        reviews_count = store_reviews_counts.get(s.store_id, 0)

        data.append(StoreOut(
            store_id=s.store_id,
            name=s.name,
            description=s.description,
            address=s.address,
            phone=s.phone,
            email=s.email,
            website=s.website,
            status=s.status,
            date_added=s.date_added.isoformat() if s.date_added else None,
            date_modify=s.date_modify.isoformat() if s.date_modify else None,
            rating=s.rating,
            viewed=s.viewed,
            seo_keyword=s.seo_keyword,
            meta_title=s.meta_title,
            meta_description=s.meta_description,
            meta_keyword=s.meta_keyword,
            logo=s.logo,
            reviews_count=reviews_count,  # Додано: кількість відгуків магазину
        ))
    return ResponseWrapperStoreTop(data=data, status=True)


@router.get("/topManufacturer", response_model=ResponseWrapper)
async def get_top_manufacturers(session: AsyncSession = Depends(get_db)):
    TOP_IDS = [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

    # Отримуємо кількість відгуків для кожного виробника
    manufacturer_reviews_query = await session.execute(
        select(
            ManufacturerReview.manufacturer_id,
            func.count(ManufacturerReview.manufacturer_review_id).label('reviews_count')
        )
        .where(
            ManufacturerReview.status == ReviewStatusEnum.approved,
            ManufacturerReview.manufacturer_id.in_(TOP_IDS)
        )
        .group_by(ManufacturerReview.manufacturer_id)
    )
    manufacturer_reviews_counts = {row.manufacturer_id: row.reviews_count for row in manufacturer_reviews_query}

    result = await session.execute(
        select(Manufacturer)
        .options(selectinload(Manufacturer.photos))
        .where(Manufacturer.manufacturer_id.in_(TOP_IDS))
        .order_by(desc(Manufacturer.viewed))
    )
    manufacturers = result.scalars().all()

    data = [
        ManufacturerOut(
            manufacturer_id=m.manufacturer_id,
            name=m.name,
            description=m.description,
            address=m.address,
            phone=m.phone,
            email=m.email,
            status=m.status,
            rating=m.rating,
            viewed=m.viewed,
            logo=m.logo,
            date_added=m.date_added,
            date_modify=m.date_modify,
            seo_keyword=m.seo_keyword,
            reviews_count=manufacturer_reviews_counts.get(m.manufacturer_id, 0),  # Додано: кількість відгуків виробника
        )
        for m in manufacturers
    ]

    return {"data": data, "status": True}


@router.get("/lastReview", response_model=ResponseWrapper)
async def get_latest_service_reviews(session: AsyncSession = Depends(get_db)):
    res = await session.execute(
        select(ServiceReview)
        .where(ServiceReview.status == ReviewStatusEnum.approved)
        .options(selectinload(ServiceReview.customer))
        .order_by(ServiceReview.date_added.desc())
    )

    reviews = []
    for r in res.scalars().all():
        reviews.append(ReviewOut(
            id=r.service_review_id,
            text=r.text,
            date_added=r.date_added.isoformat(),
            type="service",
            rating=r.rating,
            customer=CustomerOut(
                name=r.customer.name,
                photo=r.customer.logo
            ) if r.customer else None
        ))

    # беремо останні 4 за датою
    reviews = sorted(reviews, key=lambda x: x.date_added, reverse=True)[:4]

    return {"data": reviews, "status": True}


@router.get("/dayProduct")
async def get_day_product():
    response = await ServicePublic.get_public_product(5)
    return response

@router.get("/topCategories")
async def get_top_categories(
    quantity_cats: Optional[int] = Query(16, description="Кількість категорій"),
):
    from src.cache.cache import CATEGORIES_CACHE
    
    # Получаем все категории из кеша
    categories = list(CATEGORIES_CACHE.values())
    
    # Фильтруем только активные категории (status = 1)
    active_categories = [c for c in categories if c.get("status") == 1]
    
    # Сортируем по количеству просмотров в убывающем порядке
    sorted_categories = sorted(active_categories, key=lambda x: x.get("viewed", 0), reverse=True)
    top = sorted_categories[:quantity_cats]
    
    data = [
        {
            "category_id": c["id_category"],
            "name": c["name"],
            "seo_keyword": c["seo_keyword"],
            "image": c["image"],
            "status": c["status"],
            "viewed": c.get("viewed", 0),
        }
        for c in top
    ]

    return {"data": data, "status": True}


@router.post("/review/store")
async def create_store_review(
        review: StoreReviewCreate,
        request: Request,
        db: AsyncSession = Depends(get_db),
        current_account=Depends(decode_token)
):
    if not current_account['user_id']:
        return {
            "data": [],
            "status": False,
            "error": "Невідомий користувач"
        }
    else:
        client_ip = request.client.host
        review_db = StoreReview(
            customer_id=current_account['user_id'],
            store_id=review.store_id,
            text=review.text,
            rating=review.rating,
            ip=client_ip,
            status=ReviewStatusEnum.new,
            date_added=datetime.utcnow(),
            date_modify=datetime.utcnow()
        )
        db.add(review_db)
        await db.commit()
        await db.refresh(review_db)
        return {"data": review_db, "status": True}


@router.post("/review/manufacturer")
async def create_manufacturer_review(
        review: ManufacturerReviewCreate,
        request: Request,
        db: AsyncSession = Depends(get_db),
        current_account=Depends(decode_token)
):
    if not current_account['user_id']:
        return {
            "data": [],
            "status": False,
            "error": "Невідомий користувач"
        }
    else:
        client_ip = request.client.host
        review_db = ManufacturerReview(
            customer_id=current_account['user_id'],
            manufacturer_id=review.manufacturer_id,
            text=review.text,
            rating=review.rating,
            ip=client_ip,
            status=ReviewStatusEnum.new,
            date_added=datetime.utcnow(),
            date_modify=datetime.utcnow()
        )
        db.add(review_db)
        await db.commit()
        await db.refresh(review_db)
        return {"data": review_db, "status": True}


@router.post("/review/service")
async def create_service_review(
        review: ServiceReviewCreate,
        request: Request,
        db: AsyncSession = Depends(get_db),
        current_account=Depends(decode_token)
):
    if not current_account['user_id']:
        return {
            "data": [],
            "status": False,
            "error": "Невідомий користувач"
        }
    else:
        client_ip = request.client.host
        review_db = ServiceReview(
            customer_id=current_account['user_id'],
            text=review.text,
            rating=review.rating,
            ip=client_ip,
            status=ReviewStatusEnum.new,
            date_added=datetime.utcnow(),
            date_modify=datetime.utcnow()
        )
        db.add(review_db)
        await db.commit()
        await db.refresh(review_db)
        return {"data": review_db, "status": True}


@router.post("/review/product")
async def create_product_review(
        review: ProductReviewCreate,
        request: Request,
        db: AsyncSession = Depends(get_db),
        current_account=Depends(decode_token)
):
    if not current_account['user_id']:
        return {
            "data": [],
            "status": False,
            "error": "Невідомий користувач"
        }
    else:
        client_ip = request.client.host
        review_db = ProductReview(
            customer_id=current_account['user_id'],
            product_id=review.product_id,
            text=review.text,
            rating=review.rating,
            ip=client_ip,
            status=ReviewStatusEnum.new,
            date_added=datetime.utcnow(),
            date_modify=datetime.utcnow()
        )
        db.add(review_db)
        await db.commit()
        await db.refresh(review_db)
        return {"data": review_db, "status": True}


@router.get("/product")
async def get_public_products(
        page: int = Query(1, ge=1),
        limit: int = Query(10, ge=1, le=100),
        needle: Optional[str] = Query(None, description="Пошук по назві продукту"),
        category_id: Optional[int] = Query(None, description="Фільтр по категорії"),
        manufacturer_id: Optional[int] = Query(None, description="Фільтр по виробнику"),
        price_min: Optional[float] = Query(None, description="Мінімальна ціна"),
        price_max: Optional[float] = Query(None, description="Максимальна ціна"),
        special: Optional[bool] = Query(False, description="Якщо True - то тільки товари зі знижкою"),
        selected: Optional[bool] = Query(False, description="Якщо True - то тільки товари з 'Обраного'"),
        sort_field: str = Query("name",
                                description="Поле для сортування: name | price | date_added | date_modify | rating | reviews_count | viewed"),
        sort_order: str = Query("asc", description="Порядок сортування: asc / desc"),
        filter_groups: Optional[str] = Query(None, description="JSON строка групп фільтрів: {group_id: [filter_ids]}"),
        stores: Optional[str] = Query(None, description="JSON массив магазинів"),
        db: AsyncSession = Depends(get_db),
        current_account=Depends(decode_token_optional)
):
    """
    Повертає список продуктів з кешу з фільтрацією, сортуванням та пагінацією.
    Підтримує фільтрацію за фільтрами з логікою OR всередині групи та AND між групами.
    """
    customer_id = current_account.get('user_id') if current_account else None

    # Парсинг JSON строки filter_groups
    parsed_filter_groups = None
    if filter_groups:
        try:
            parsed_filter_groups = json.loads(filter_groups)
            # Проверяем что это словарь
            if not isinstance(parsed_filter_groups, dict):
                raise HTTPException(status_code=400, detail="filter_groups должен быть объектом/словарем")

            # Конвертируем ключи в int и проверяем значения
            converted_filter_groups = {}
            for k, v in parsed_filter_groups.items():
                try:
                    group_id = int(k)
                    if not isinstance(v, list):
                        raise HTTPException(status_code=400, detail=f"Значение для группы {k} должно быть массивом")
                    if not all(isinstance(filter_id, int) for filter_id in v):
                        raise HTTPException(status_code=400, detail=f"Все ID фильтров в группе {k} должны быть числами")
                    converted_filter_groups[group_id] = v
                except ValueError:
                    raise HTTPException(status_code=400, detail=f"ID группы '{k}' должен быть числом")

            parsed_filter_groups = converted_filter_groups

        except json.JSONDecodeError as e:
            raise HTTPException(status_code=400, detail=f"Неверный JSON формат: {str(e)}")
        except HTTPException:
            raise  # Перебрасываем наши собственные ошибки
        except Exception as e:
            raise HTTPException(status_code=400, detail=f"Ошибка обработки filter_groups: {str(e)}")

    parsed_stores = None
    if stores:
        try:
            parsed_stores = json.loads(stores)
        except:
            parsed_stores = None

    return await ServicePublic.get_public_products(
        db=db,
        customer_id=customer_id,
        page=page,
        limit=limit,
        needle=needle,
        category_id=category_id,
        manufacturer_id=manufacturer_id,
        price_min=price_min,
        price_max=price_max,
        sort_field=sort_field,
        sort_order=sort_order,
        filter_groups=parsed_filter_groups,
        special=special,
        selected=selected,
        stores=parsed_stores
    )


@router.get("/product/{product_id}")
async def get_public_products(product_id: int, bg_task: BackgroundTasks, db: AsyncSession = Depends(get_db)):
    bg_task.add_task(ServicePublic.update_product_views, db=db, product_id=product_id)

    response = await ServicePublic.get_public_product(product_id)
    matched_products = await ServicePublic.get_public_products(
        db=db, customer_id=None, page=1, limit=10, needle=None, category_id=response['data']['categories'][-1]['id'],
        manufacturer_id=None, price_min=None, price_max=None, sort_field="name", sort_order="random", filter_groups=None
    )

    response['data']['matched_products'] = matched_products['data']

    return response


@router.get("/listCategories", summary="Отримати список категорій")
async def list_categories(
        page: int = Query(1, ge=1),
        limit: int = Query(10, ge=1),
        needle: Optional[str] = Query(None, description="Пошук по назві категорії"),
        status: Optional[int] = Query(None, description="Фільтр по статусу: 0/1"),
        sort_field: str = Query("name", description="Поле для сортування: name | date_added | date_modify | status"),
        sort_order: str = Query("asc", description="Порядок сортування: asc / desc")
):
    """
    Повертає список категорій з кешу з фільтрацією, сортуванням та пагінацією.
    Категорії з визначеним sort_order завжди показуються першими у встановленому порядку.
    """
    return await ServicePublic.list_categories_tree(page, limit, needle, status, sort_field, sort_order)


@router.get("/seo/category", summary="Отримати категорію по ЧПУ")
async def get_seo_category(
        bg_task: BackgroundTasks,
        keyword: Optional[str] = Query("keyword", description="ЧПУ"),
        db: AsyncSession = Depends(get_db)
):
    result = await ServicePublic.get_category_id_by_seo(keyword)

    if result['status'] == True:
        bg_task.add_task(ServicePublic.update_category_views, db=db, category_id=result['data']['id_category'])
    return result


@router.get("/seo/product", summary="Отримати товар по ЧПУ")
async def get_seo_product(
        bg_task: BackgroundTasks,
        keyword: Optional[str] = Query("keyword", description="ЧПУ"),
        db: AsyncSession = Depends(get_db),
        current_account=Depends(decode_token_optional)
):
    customer_id = current_account.get('user_id') if current_account else None
    result = await ServicePublic.get_product_id_by_seo(db, keyword, customer_id)

    if result["status"] and result["data"]:
        product_id = result["data"]["product_id"]
        bg_task.add_task(ServicePublic.update_product_views, db=db, product_id=product_id)

        # Добавляем похожие товары если есть категории
        if result["data"].get("categories"):
            category_id = result["data"]["categories"][-1]["id"]
            matched_products = await ServicePublic.get_public_products(
                db=db, customer_id=customer_id, page=1, limit=10, needle=None, category_id=category_id,
                manufacturer_id=None, price_min=None, price_max=None, sort_field="name", sort_order="random", filter_groups=None
            )
            result['data']['matched_products'] = matched_products['data']
    return result


@router.get("/seo/store", summary="Отримати магазин по ЧПУ")
async def get_seo_store(
        keyword: Optional[str] = Query("keyword", description="ЧПУ"),
        db: AsyncSession = Depends(get_db)
):
    response = await ServicePublic.get_store_id_by_seo(keyword, db)
    stats = await ServicePublic.get_store_reviews_statistics(db=db, store_id=response['data']['store_id'])
    response['data']['stats'] = stats['data']
    return response

@router.get("/seo/manufacturer", summary="Отримати магазин по ЧПУ")
async def get_seo_manufacturer(
        keyword: Optional[str] = Query("keyword", description="ЧПУ"),
        db: AsyncSession = Depends(get_db)
):
    return await ServicePublic.get_manufacturer_id_by_seo(db, keyword)

@router.get("/seo/cart", summary="Отримати публічну корзину по ЧПУ")
async def get_seo_cart(
        keyword: Optional[str] = Query("keyword", description="ЧПУ"),
        db: AsyncSession = Depends(get_db)
):
    from src.cart.service import CartService
    return await CartService.get_shared_cart_by_seo(db, keyword)


@router.get("/productReview")
async def list_product_reviews(
        product_id: int = Query(..., description="ID продукту"),
        page: int = Query(1, ge=1),
        limit: int = Query(10, ge=1),
        db: AsyncSession = Depends(get_db),
):
    result = await ServicePublic.get_product_review(db, product_id, page, limit)
    return result


@router.get("/storeReview")
async def list_store_reviews(
        store_id: Optional[int] = Query(None, description="ID магазину для фільтрації відгуків"),
        page: int = Query(1, ge=1),
        limit: int = Query(10, ge=1),
        db: AsyncSession = Depends(get_db),
):
    result = await ServicePublic.get_store_review(db, store_id, page, limit)
    return result


@router.get("/manufacturerReview")
async def list_manufacturer_reviews(
        manufacturer_id: Optional[int] = Query(None, description="ID виробника для фільтрації відгуків"),
        page: int = Query(1, ge=1),
        limit: int = Query(10, ge=1),
        db: AsyncSession = Depends(get_db),
):
    """
    Отримати список відгуків про виробників з пагінацією та фільтрацією за ID виробника
    """
    result = await ServicePublic.get_manufacturer_review(db, manufacturer_id, page, limit)
    return result


@router.get("/serviceReview")
async def list_service_reviews(
        page: int = Query(1, ge=1),
        limit: int = Query(10, ge=1),
        db: AsyncSession = Depends(get_db),
):
    """
    Отримати список відгуків про сервіс з пагінацією
    """
    result = await ServicePublic.get_service_review(db, page, limit)
    return result


@router.get("/stores", response_model=ResponseWrapperStore)
async def list_stores(
        needle: Optional[str] = Query(None, description="Пошук по назві магазину"),
        sort_field: str = Query(
            "date_added",
            regex="^(name|date_added|id|rating|reviews_count)$",
            description="Поле сортування магазину (name, date_added, id, rating, reviews_count)"
        ),
        sort_order: str = Query(
            "DESC",
            regex="^(ASC|DESC|asc|desc)$",
            description="Напрям сортування: ASC/asc=зростання, DESC/desc=спадання"
        ),
        page: int = Query(1, ge=1, description="Номер сторінки"),
        limit: int = Query(10, ge=1, description="Кількість на сторінці"),
        db: AsyncSession = Depends(get_db),
):
    try:
        result = await ServicePublic.get_stores_list(
            db=db,
            needle=needle,
            sort_field=sort_field,
            sort_order=sort_order,
            page=page,
            limit=limit,
        )
        return {
            "data": result["items"],
            "total": result["total"],
            "page": page,
            "limit": limit,
            "status": True,
        }
    except Exception as e:
        return {
            "data": [],
            "status": False,
            "message": str(e),
            "total": 0,
            "page": page,
            "limit": limit,
        }


@router.get("/store/{store_id}")
async def get_store_by_id(
        store_id: int,
        db: AsyncSession = Depends(get_db)
):
    try:
        store = await ServicePublic.get_store_by_id(db=db, store_id=store_id)
        return {
            "data": store,
            "status": True,
        }
    except HTTPException as e:
        return {
            "data": None,
            "status": False,
            "message": e.detail,
        }
    except Exception as e:
        return {
            "data": None,
            "status": False,
            "message": str(e),
        }


@router.get("/store/{store_id}/addresses", summary="Отримати адреси магазину")
async def get_store_addresses(
        store_id: int = Path(..., description="ID магазину"),
        page: int = Query(1, ge=1, description="Номер сторінки"),
        limit: int = Query(10, ge=1, description="Кількість на сторінку"),
        city_id: Optional[int] = Query(None, description="Фільтр по ID міста"),
        zone_id: Optional[int] = Query(None, description="Фільтр по ID області"),
        needle: Optional[str] = Query(None, description="Пошук по адресі"),
        db: AsyncSession = Depends(get_db),
):
    return await ServicePublic.get_store_addresses(db, store_id, page, limit, city_id, zone_id, needle)




@router.post("/review/product/{product_review_id}/response", summary="Створити відповідь на відгук про товар")
async def create_product_review_response(
        product_review_id: int = Path(..., description="ID відгуку про товар"),
        body: ReviewResponseCreate = Body(...),
        request: Request = None,
        db: AsyncSession = Depends(get_db)
):
    """
    Створити відповідь на відгук про товар.
    Автор автоматично визначається як customer з ID=2 (хардкод).
    """
    client_ip = request.client.host if request else "127.0.0.1"

    result = await ReviewResponseService.create_product_review_response(
        db=db,
        product_review_id=product_review_id,
        response_text=body.response_text,
        ip=client_ip
    )

    return result


@router.post("/review/store/{store_review_id}/response", summary="Створити відповідь на відгук про магазин")
async def create_store_review_response(
        store_review_id: int = Path(..., description="ID відгуку про магазин"),
        body: ReviewResponseCreate = Body(...),
        request: Request = None,
        db: AsyncSession = Depends(get_db)
):
    """
    Створити відповідь на відгук про магазин.
    Автор автоматично визначається як customer з ID=2 (хардкод).
    """
    client_ip = request.client.host if request else "127.0.0.1"

    result = await ReviewResponseService.create_store_review_response(
        db=db,
        store_review_id=store_review_id,
        response_text=body.response_text,
        ip=client_ip
    )

    return result


@router.post("/review/manufacturer/{manufacturer_review_id}/response",
             summary="Створити відповідь на відгук про виробника")
async def create_manufacturer_review_response(
        manufacturer_review_id: int = Path(..., description="ID відгуку про виробника"),
        body: ReviewResponseCreate = Body(...),
        request: Request = None,
        db: AsyncSession = Depends(get_db)
):
    """
    Створити відповідь на відгук про виробника.
    Автор автоматично визначається як customer з ID=2 (хардкод).
    """
    client_ip = request.client.host if request else "127.0.0.1"

    result = await ReviewResponseService.create_manufacturer_review_response(
        db=db,
        manufacturer_review_id=manufacturer_review_id,
        response_text=body.response_text,
        ip=client_ip
    )

    return result


@router.post("/review/service/{service_review_id}/response", summary="Створити відповідь на відгук про сервіс")
async def create_service_review_response(
        service_review_id: int = Path(..., description="ID відгуку про сервіс"),
        body: ReviewResponseCreate = Body(...),
        request: Request = None,
        db: AsyncSession = Depends(get_db)
):
    """
    Створити відповідь на відгук про сервіс.
    Автор автоматично визначається як customer з ID=2 (хардкод).
    """
    client_ip = request.client.host if request else "127.0.0.1"

    result = await ReviewResponseService.create_service_review_response(
        db=db,
        service_review_id=service_review_id,
        response_text=body.response_text,
        ip=client_ip
    )

    return result


# Ендпоїнти для отримання відповідей (оновлені)
@router.get("/review/product/{product_review_id}/responses", summary="Отримати відповіді на відгук про товар")
async def get_product_review_responses(
        product_review_id: int = Path(..., description="ID відгуку про товар"),
        db: AsyncSession = Depends(get_db)
):
    """
    Отримати всі схвалені відповіді на конкретний відгук про товар
    """
    responses = await ReviewResponseService.get_review_responses(
        db=db,
        review_type="product",
        review_id=product_review_id
    )

    return {
        "data": responses,
        "status": True,
        "total": len(responses)
    }


@router.get("/review/store/{store_review_id}/responses", summary="Отримати відповіді на відгук про магазин")
async def get_store_review_responses(
        store_review_id: int = Path(..., description="ID відгуку про магазин"),
        db: AsyncSession = Depends(get_db)
):
    """
    Отримати всі схвалені відповіді на конкретний відгук про магазин
    """
    responses = await ReviewResponseService.get_review_responses(
        db=db,
        review_type="store",
        review_id=store_review_id
    )

    return {
        "data": responses,
        "status": True,
        "total": len(responses)
    }


@router.get("/review/manufacturer/{manufacturer_review_id}/responses",
            summary="Отримати відповіді на відгук про виробника")
async def get_manufacturer_review_responses(
        manufacturer_review_id: int = Path(..., description="ID відгуку про виробника"),
        db: AsyncSession = Depends(get_db)
):
    """
    Отримати всі схвалені відповіді на конкретний відгук про виробника
    """
    responses = await ReviewResponseService.get_review_responses(
        db=db,
        review_type="manufacturer",
        review_id=manufacturer_review_id
    )

    return {
        "data": responses,
        "status": True,
        "total": len(responses)
    }


@router.get("/review/service/{service_review_id}/responses", summary="Отримати відповіді на відгук про сервіс")
async def get_service_review_responses(
        service_review_id: int = Path(..., description="ID відгуку про сервіс"),
        db: AsyncSession = Depends(get_db)
):
    """
    Отримати всі схвалені відповіді на конкретний відгук про сервіс
    """
    responses = await ReviewResponseService.get_review_responses(
        db=db,
        review_type="service",
        review_id=service_review_id
    )

    return {
        "data": responses,
        "status": True,
        "total": len(responses)
    }


@router.delete("/review/response/{response_id}", summary="Видалити відповідь на відгук")
async def delete_review_response(
        response_id: int = Path(..., description="ID відповіді"),
        db: AsyncSession = Depends(get_db)
):
    """
    Видалити відповідь на відгук будь-якого типу
    """
    result = await ReviewResponseService.delete_review_response(
        db=db,
        response_id=response_id
    )

    return result

@router.get("/manufacturer", response_model=ManufacturerListResponse)
async def list_manufacturers(
        needle: Optional[str] = Query(None),
        sort_field: str = Query("date_added", alias="sort[field]", description="Sort by date_added, name, rating, date_modify"),
        sort_order: str = Query("DESC", alias="sort[order]", description="DESC, ASC"),
        page: int = Query(1, ge=1),
        limit: int = Query(10, ge=1),
        db: AsyncSession = Depends(get_db),
):
    result = await ManufacturerService.get_manufacturers_list(
        db=db, needle=needle, sort_field=sort_field,
        sort_order=sort_order, page=page, limit=limit
    )
    return {
        "data": result["items"],
        "total": result["total"],
        "page": page,
        "limit": limit,
        "status": True
    }

@router.get("/manufacturer/{manufacturer_id}")
async def get_manufacturer(
    manufacturer_id: int,
    db: AsyncSession = Depends(get_db),
):
    manufacturer = await ManufacturerService.get_manufacturer_by_id(db, manufacturer_id)
    return {"data": manufacturer, "status": True}

@router.get("/manufacturer/{manufacturer_id}/photo")
async def get_manufacturer_photo(
    manufacturer_id: int = Path(..., description="Manufacturer ID"),
    page: int = Query(1, ge=1, description="Page number"),
    limit: int = Query(10, ge=1, le=100, description="Items per page"),
    db: AsyncSession = Depends(get_db)
):
    photos, total = await ManufacturerService.get_manufacturer_photo(
        manufacturer_id=manufacturer_id, db=db, page=page, limit=limit
    )
    return {
        "data": [ManufacturerPhotoResponse.model_validate(photo) for photo in photos],
        "status": True,
        "page": page,
        "limit": limit,
        "total": total,
    }

@router.get("/search")
async def search_product(
    limit: int = Query(10, ge=1, description="Ліміт пошуку"),
    needle: str = Query(None, description="Поле пошуку"),
    category_id: int = Query(None, description="Категорія"),
):
    return await ServicePublic.search_product(limit=limit, needle=needle, category_id=category_id)


@router.get("/robots.txt", response_class=Response)
async def get_robots():
    """
    Повертає robots.txt
    """
    from pathlib import Path

    robots_path = Path(__file__).resolve().parent.parent.parent / "robots.txt"

    if robots_path.exists():
        with open(robots_path, "r", encoding="utf-8") as f:
            content = f.read()
        return Response(content=content, media_type="text/plain")
    else:
        return Response(content="User-agent: *\nAllow: /\n", media_type="text/plain")


@router.get("/sitemap.xml", response_class=Response)
async def get_sitemap(db: AsyncSession = Depends(get_db)):
    """
    Генерує sitemap.xml на основі кешу товарів та категорій
    """
    from src.cache.cache import PRODUCTS_CACHE, CATEGORIES_CACHE

    # Отримуємо базовий URL з змінної оточення або використовуємо дефолтний
    base_url = os.getenv("SITE_URL", "https://example.com")

    # Початок XML
    xml_content = '<?xml version="1.0" encoding="UTF-8"?>\n'
    xml_content += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'

    # Головна сторінка
    xml_content += '  <url>\n'
    xml_content += f'    <loc>{base_url}/</loc>\n'
    xml_content += '    <changefreq>daily</changefreq>\n'
    xml_content += '    <priority>1.0</priority>\n'
    xml_content += '  </url>\n'

    # Додаємо товари з кешу
    for product in PRODUCTS_CACHE.values():
        if product.get("seo_keyword"):
            xml_content += '  <url>\n'
            xml_content += f'    <loc>{base_url}/{product["seo_keyword"]}</loc>\n'
            if product.get("date_modify"):
                xml_content += f'    <lastmod>{product["date_modify"][:10]}</lastmod>\n'
            xml_content += '    <changefreq>weekly</changefreq>\n'
            xml_content += '    <priority>0.8</priority>\n'
            xml_content += '  </url>\n'

    # Додаємо категорії з кешу
    for category in CATEGORIES_CACHE.values():
        if category.get("seo_keyword") and category.get("status") == 1:
            xml_content += '  <url>\n'
            xml_content += f'    <loc>{base_url}/{category["seo_keyword"]}</loc>\n'
            if category.get("date_modify"):
                xml_content += f'    <lastmod>{category["date_modify"][:10]}</lastmod>\n'
            xml_content += '    <changefreq>weekly</changefreq>\n'
            xml_content += '    <priority>0.7</priority>\n'
            xml_content += '  </url>\n'

    # Додаємо магазини
    from src.store.models import Store
    result = await db.execute(
        select(Store).where(Store.status == 1)
    )
    stores = result.scalars().all()
    for store in stores:
        if store.seo_keyword:
            xml_content += '  <url>\n'
            xml_content += f'    <loc>{base_url}/{store.seo_keyword}</loc>\n'
            if store.date_modify:
                xml_content += f'    <lastmod>{store.date_modify.date().isoformat()}</lastmod>\n'
            xml_content += '    <changefreq>weekly</changefreq>\n'
            xml_content += '    <priority>0.6</priority>\n'
            xml_content += '  </url>\n'

    # Додаємо виробників
    from src.manufacturer.models import Manufacturer
    result = await db.execute(
        select(Manufacturer).where(Manufacturer.status == 1)
    )
    manufacturers = result.scalars().all()
    for manufacturer in manufacturers:
        if manufacturer.seo_keyword:
            xml_content += '  <url>\n'
            xml_content += f'    <loc>{base_url}/{manufacturer.seo_keyword}</loc>\n'
            if manufacturer.date_modify:
                xml_content += f'    <lastmod>{manufacturer.date_modify.date().isoformat()}</lastmod>\n'
            xml_content += '    <changefreq>monthly</changefreq>\n'
            xml_content += '    <priority>0.5</priority>\n'
            xml_content += '  </url>\n'

    # Закриваємо XML
    xml_content += '</urlset>'

    return Response(content=xml_content, media_type="application/xml")