import type { APIRoute } from "astro";

const POCKETBASE_URL = import.meta.env.POCKETBASE_URL || "http://localhost:8090";

export const GET: APIRoute = async ({ url }) => {
  const status = url.searchParams.get("status") || "published";
  const category = url.searchParams.get("category");

  // Формируем фильтр
  let filter = `status = "${status}"`;

  if (category) {
    filter += ` && case_category = "${category}"`;
  }

  const expand = "case_category,user";
  const sort = "-created";

  try {
    const response = await fetch(
      `${POCKETBASE_URL}/api/collections/reviews/records?expand=${expand}&filter=${encodeURIComponent(filter)}&sort=${sort}`,
      {
        headers: {
          "Content-Type": "application/json",
        },
      }
    );

    const data = await response.json();
    return new Response(JSON.stringify(data), {
      status: 200,
      headers: { "Content-Type": "application/json" },
    });
  } catch (error) {
    console.error("[Reviews API GET] Error:", error);
    return new Response(
      JSON.stringify({ error: "Failed to fetch reviews" }),
      {
        status: 500,
        headers: { "Content-Type": "application/json" },
      }
    );
  }
};

export const POST: APIRoute = async ({ request, cookies }) => {
  try {
    const body = await request.json();
    console.log("[Reviews API POST] Получены данные:", body);

    // Получаем токен авторизации из кук
    const pbAuthCookie = cookies.get("pb_auth")?.value;

    if (!pbAuthCookie) {
      console.error("[Reviews API POST] Токен авторизации не найден");
      return new Response(
        JSON.stringify({ error: "Требуется авторизация", errorCode: "unauthorized" }),
        {
          status: 401,
          headers: { "Content-Type": "application/json" },
        }
      );
    }

    const token = pbAuthCookie.trim();
    console.log("[Reviews API POST] Токен получен (первые 30 символов):", token.substring(0, 30));

    // Валидация данных
    const { role, caseType, rating, text } = body;

    if (!role || !caseType || !rating || !text) {
      return new Response(
        JSON.stringify({ error: "Все поля обязательны для заполнения", errorCode: "validation_error" }),
        {
          status: 400,
          headers: { "Content-Type": "application/json" },
        }
      );
    }

    // Сначала проверяем токен - получаем данные текущего пользователя
    let userId = "";
    let authData: any = null;
    try {
      console.log("[Reviews API POST] Проверка токена через auth-refresh...");
      const authResponse = await fetch(
        `${POCKETBASE_URL}/api/collections/users/auth-refresh`,
        {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
            Authorization: `Bearer ${token}`,
          },
        }
      );

      if (authResponse.ok) {
        authData = await authResponse.json();
        userId = authData.record?.id || "";
        console.log("[Reviews API POST] Пользователь авторизован:", userId, authData.record?.email);
      } else {
        const errorText = await authResponse.text();
        console.error("[Reviews API POST] Токен невалиден:", errorText);
        return new Response(
          JSON.stringify({ error: "Недействительная сессия", errorCode: "invalid_session" }),
          {
            status: 401,
            headers: { "Content-Type": "application/json" },
          }
        );
      }
    } catch (error) {
      console.error("[Reviews API POST] Ошибка проверки токена:", error);
      return new Response(
        JSON.stringify({ error: "Ошибка проверки авторизации", errorCode: "auth_error" }),
        {
          status: 500,
          headers: { "Content-Type": "application/json" },
        }
      );
    }

    // Находим категорию по имени
    let caseCategoryId = "";
    try {
      console.log("[Reviews API POST] Поиск категории:", caseType);
      
      // Сначала получим все категории для отладки
      const allCategoriesResponse = await fetch(
        `${POCKETBASE_URL}/api/collections/case_categories/records`,
        {
          headers: {
            "Content-Type": "application/json",
            Authorization: `Bearer ${token}`,
          },
        }
      );
      
      if (allCategoriesResponse.ok) {
        const allCategoriesData = await allCategoriesResponse.json();
        console.log("[Reviews API POST] Все категории в базе:", allCategoriesData.items?.map((c: any) => ({ id: c.id, name: c.name })));
      }
      
      // Теперь ищем по имени
      const categoriesResponse = await fetch(
        `${POCKETBASE_URL}/api/collections/case_categories/records?filter=name%3D%22${encodeURIComponent(caseType)}%22`,
        {
          headers: {
            "Content-Type": "application/json",
            Authorization: `Bearer ${token}`,
          },
        }
      );

      if (categoriesResponse.ok) {
        const categoriesData = await categoriesResponse.json();
        console.log("[Reviews API POST] Результат поиска:", categoriesData);
        if (categoriesData.items && categoriesData.items.length > 0) {
          caseCategoryId = categoriesData.items[0].id;
          console.log("[Reviews API POST] Категория найдена:", caseCategoryId);
        } else {
          console.warn("[Reviews API POST] Категория не найдена, создаем без категории");
        }
      } else {
        console.error("[Reviews API POST] Ошибка поиска категории:", await categoriesResponse.text());
      }
    } catch (error) {
      console.error("[Reviews API POST] Ошибка поиска категории:", error);
    }

    // Создаем отзыв в PocketBase
    // Имя берем автоматически из данных пользователя
    const userName = authData?.record?.name || authData?.record?.email?.split('@')[0] || "Аноним";

    const reviewData: Record<string, any> = {
      name: userName,  // Автоматически из профиля пользователя
      role,
      rating: parseInt(rating, 10),
      text,
      status: "published", // Публикуется сразу
      isPublished: true, // Опубликовано
      user: userId,  // Связь с пользователем
    };

    // Добавляем категорию, если найдена
    if (caseCategoryId) {
      reviewData.case_category = caseCategoryId;
    }

    console.log("[Reviews API POST] Отправка в PocketBase:", reviewData);

    const response = await fetch(
      `${POCKETBASE_URL}/api/collections/reviews/records`,
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${token}`,
        },
        body: JSON.stringify(reviewData),
      }
    );

    const responseData = await response.json();
    console.log("[Reviews API POST] Ответ PocketBase (статус:", response.status, "):", responseData);

    if (!response.ok) {
      console.error("[Reviews API POST] Ошибка PocketBase:", responseData);
      
      return new Response(
        JSON.stringify({ 
          error: responseData.message || "Ошибка при создании отзыва",
          errorCode: responseData.code || "create_failed",
          data: responseData.data || {}
        }),
        {
          status: response.status,
          headers: { "Content-Type": "application/json" },
        }
      );
    }

    console.log("[Reviews API POST] Отзыв создан:", responseData.id);

    return new Response(
      JSON.stringify({ 
        success: true, 
        message: "Отзыв успешно создан и отправлен на модерацию",
        reviewId: responseData.id
      }),
      {
        status: 201,
        headers: { "Content-Type": "application/json" },
      }
    );
  } catch (error) {
    console.error("[Reviews API POST] Исключение:", error);
    return new Response(
      JSON.stringify({ error: "Ошибка сервера", errorCode: "server_error" }),
      {
        status: 500,
        headers: { "Content-Type": "application/json" },
      }
    );
  }
};
