import type { APIRoute } from "astro";

const POCKETBASE_URL = "http://localhost:8090";

// Функция логирования с временной меткой
function log(message: string, data?: unknown) {
  const timestamp = new Date().toISOString();
  console.log(
    `[LOGIN API][${timestamp}] ${message}`,
    data ? JSON.stringify(data, null, 2) : "",
  );
}

function logError(message: string, error?: unknown) {
  const timestamp = new Date().toISOString();
  console.error(`[LOGIN API][${timestamp}] ERROR: ${message}`);
  if (error instanceof Error) {
    console.error(`[LOGIN API][${timestamp}] Stack:`, error.stack);
    console.error(`[LOGIN API][${timestamp}] Message:`, error.message);
  } else {
    console.error(`[LOGIN API][${timestamp}] Error:`, error);
  }
}

export const POST: APIRoute = async ({ request, cookies }) => {
  const requestId = crypto.randomUUID();
  log(`=== Начало входа пользователя #${requestId} ===`);

  try {
    let body;
    try {
      body = await request.json();
    } catch (parseError) {
      logError(`Ошибка парсинга JSON #${requestId}:`, parseError);
      return new Response(JSON.stringify({ error: "Неверный формат данных" }), {
        status: 400,
        headers: { "Content-Type": "application/json" },
      });
    }

    const { email, password, remember } = body;
    log(`Получены данные: email=${email}, hasPassword=${!!password}, remember=${remember}`);

    if (!email || !password) {
      logError(
        `Валидация не пройдена #${requestId}: email или пароль не указаны`,
      );
      return new Response(
        JSON.stringify({ error: "Email и пароль обязательны" }),
        { status: 400, headers: { "Content-Type": "application/json" } },
      );
    }

    // Аутентификация в PocketBase
    log("Запрос аутентификации в PocketBase...");

    const authResponse = await fetch(
      `${POCKETBASE_URL}/api/collections/users/auth-with-password`,
      {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          identity: email, // Оставляем identity (правильно для PocketBase)
          password,
        }),
      },
    );

    log(`Ответ PocketBase: статус ${authResponse.status}`);

    const data = await authResponse.json();

    if (!authResponse.ok) {
      logError(`Ошибка аутентификации #${requestId}:`, data);
      
      // Определяем тип ошибки от PocketBase
      let errorMessage = "Неверный email или пароль";
      const pbStatus = authResponse.status;
      
      if (pbStatus === 400) {
        // PocketBase возвращает 400 при неверных учётных данных
        errorMessage = data.message || "Неверный email или пароль";
        log(`PocketBase error message: ${errorMessage}`);
      } else if (pbStatus === 401) {
        errorMessage = "Неверный email или пароль";
      } else if (pbStatus === 403) {
        errorMessage = "Аккаунт заблокирован или не активен";
      } else if (pbStatus === 404) {
        errorMessage = "Пользователь не найден";
      } else if (pbStatus === 429) {
        errorMessage = "Слишком много попыток входа. Попробуйте позже";
      } else {
        errorMessage = data.message || "Ошибка входа. Попробуйте позже";
      }
      
      return new Response(
        JSON.stringify({
          error: errorMessage,
          errorCode: data.code || "auth_failed",
          pbStatus: pbStatus,
        }),
        {
          status: pbStatus,
          headers: { "Content-Type": "application/json" },
        },
      );
    }

    // Проверка верификации email
    if (!data.record?.verified) {
      logError(`Email не подтверждён #${requestId}`);
      return new Response(
        JSON.stringify({
          error: "Подтвердите email перед входом. Проверьте вашу почту.",
          verified: false,
        }),
        { status: 403, headers: { "Content-Type": "application/json" } },
      );
    }

    log(`✅ Вход успешен #${requestId}: user ${data.record.id}`);
    log(`Токен (первые 20 символов): ${data.token.substring(0, 20)}...`);
    log(`Длина токена: ${data.token.length}`);

    const isHttps = request.headers.get("x-forwarded-proto") === "https";

    // Устанавливаем куку с токеном.
    // Если "Запомнить меня" отмечен — 30 дней, иначе — сессионная кука
    const cookieOptions: any = {
      path: "/",
      httpOnly: false,
      sameSite: "lax",
      secure: isHttps,
    };

    if (remember) {
      // "Запомнить меня" отмечен — устанавливаем на 30 дней
      cookieOptions.maxAge = 60 * 60 * 24 * 30; // 30 дней
      log(`Установка куки на 30 дней (remember=true)`);
    } else {
      // "Запомнить меня" не отмечен — сессионная кука (исчезнет после закрытия браузера)
      log(`Установка сессионной куки (remember=false)`);
    }

    cookies.set("pb_auth", data.token, cookieOptions);

    // Возвращаем ответ. Astro автоматически прикрепит заголовки кук из cookies.set()
    return new Response(
      JSON.stringify({
        success: true,
        message: "Вход выполнен успешно",
        user: {
          id: data.record.id,
          email: data.record.email,
          name: data.record.name,
          verified: data.record.verified,
        },
      }),
      {
        status: 200,
        headers: {
          "Content-Type": "application/json",
        },
      },
    );
  } catch (error) {
    logError(`Необработанное исключение #${requestId}:`, error);
    return new Response(
      JSON.stringify({
        error: "Внутренняя ошибка сервера",
        details: error instanceof Error ? error.message : String(error),
      }),
      { status: 500, headers: { "Content-Type": "application/json" } },
    );
  }
};
