import type { APIRoute } from 'astro';

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

// Минимальные требования к паролю
const PASSWORD_MIN_LENGTH = 8;
const PASSWORD_MAX_LENGTH = 12;
const PASSWORD_REGEX = /^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]+$/;

function validatePassword(password: string): { valid: boolean; error?: string } {
  if (!password || password.length < PASSWORD_MIN_LENGTH) {
    return { valid: false, error: 'Пароль должен быть не менее 8 символов' };
  }
  if (password.length > PASSWORD_MAX_LENGTH) {
    return { valid: false, error: 'Пароль не должен превышать 12 символов' };
  }
  if (!PASSWORD_REGEX.test(password)) {
    return { valid: false, error: 'Пароль должен содержать хотя бы одну букву и одну цифру' };
  }
  return { valid: true };
}

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

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

export const POST: APIRoute = async ({ request }) => {
  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 { token, password, passwordConfirm } = body;
    log(`Получен токен: ${token ? token.substring(0, 20) + '...' : 'undefined'}`);

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

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

    if (password !== passwordConfirm) {
      logError(`Валидация не пройдена #${requestId}: пароли не совпадают`);
      return new Response(
        JSON.stringify({ error: 'Пароли не совпадают' }),
        { status: 400, headers: { 'Content-Type': 'application/json' } }
      );
    }

    // Проверка сложности пароля
    const passwordValidation = validatePassword(password);
    if (!passwordValidation.valid) {
      logError(`Валидация не пройдена #${requestId}: ${passwordValidation.error}`);
      return new Response(
        JSON.stringify({ error: passwordValidation.error }),
        { status: 400, headers: { 'Content-Type': 'application/json' } }
      );
    }

    // Подтверждение сброса пароля в PocketBase
    const confirmUrl = `${POCKETBASE_URL}/api/collections/users/confirm-password-reset`;
    log(`Запрос в PocketBase: POST ${confirmUrl}`);
    log(`Тело запроса: ${JSON.stringify({ token, password: '***', passwordConfirm: '***' })}`);

    let response;
    try {
      response = await fetch(confirmUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ token, password, passwordConfirm }),
      });
    } catch (fetchError) {
      logError(`Ошибка fetch запроса #${requestId}:`, fetchError);
      return new Response(
        JSON.stringify({
          error: 'Не удалось подключиться к PocketBase',
          details: fetchError instanceof Error ? fetchError.message : String(fetchError)
        }),
        { status: 503, headers: { 'Content-Type': 'application/json' } }
      );
    }

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

    // Статус 204 означает успех без тела ответа
    if (response.status === 204) {
      log(`✅ Пароль сброшен #${requestId} (204 No Content)`);
      return new Response(
        JSON.stringify({
          success: true,
          message: 'Пароль успешно изменён'
        }),
        { status: 200, headers: { 'Content-Type': 'application/json' } }
      );
    }

    let data;
    try {
      data = await response.json();
    } catch (parseError) {
      logError(`Ошибка парсинга ответа PocketBase #${requestId}:`, parseError);
      const textData = await response.text();
      log(`Текст ответа: ${textData}`);
      return new Response(
        JSON.stringify({ error: 'Ошибка обработки ответа' }),
        { status: 500, headers: { 'Content-Type': 'application/json' } }
      );
    }

    log('Ответ PocketBase (данные):', data);

    if (!response.ok) {
      logError(`Ошибка PocketBase #${requestId} (${response.status}):`, data);
      return new Response(
        JSON.stringify({
          error: data.message || 'Неверный или истёкший токен сброса пароля',
          pbData: data
        }),
        { status: response.status, headers: { 'Content-Type': 'application/json' } }
      );
    }

    log(`✅ Пароль сброшен #${requestId}`);

    return new Response(
      JSON.stringify({
        success: true,
        message: 'Пароль успешно изменён'
      }),
      { 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' } }
    );
  }
};
