import type { APIRoute } from 'astro';

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

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

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

export const POST: APIRoute = async ({ request }) => {
  const requestId = crypto.randomUUID();
  log(`=== Начало подтверждения email #${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 } = 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' } }
      );
    }

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

    let response;
    try {
      response = await fetch(confirmUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ token }),
      });
    } 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(`✅ Email подтверждён #${requestId} (204 No Content)`);
      
      // Получаем данные пользователя отдельно
      try {
        // Декодируем токен чтобы получить ID пользователя
        const tokenParts = token.split('.');
        const tokenPayload = JSON.parse(atob(tokenParts[1]));
        
        log('Данные из токена:', tokenPayload);
        
        // Получаем данные пользователя из PocketBase
        const userResponse = await fetch(`${POCKETBASE_URL}/api/collections/users/${tokenPayload.id}`, {
          method: 'GET',
          headers: { 'Content-Type': 'application/json' },
        });
        
        if (userResponse.ok) {
          const userData = await userResponse.json();
          log('Данные пользователя:', userData);
          
          return new Response(
            JSON.stringify({ 
              success: true,
              message: 'Email успешно подтверждён',
              user: {
                id: userData.id,
                email: userData.email,
                verified: userData.verified,
              }
            }),
            { status: 200, headers: { 'Content-Type': 'application/json' } }
          );
        }
      } catch (userError) {
        logError(`Ошибка получения данных пользователя #${requestId}:`, userError);
        // Продолжаем без данных пользователя
      }
      
      return new Response(
        JSON.stringify({ 
          success: true,
          message: 'Email успешно подтверждён'
        }),
        { 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(`✅ Email подтверждён #${requestId}`);

    return new Response(
      JSON.stringify({ 
        success: true,
        message: 'Email успешно подтверждён',
        user: {
          id: data.record?.id || data.id,
          email: data.record?.email || data.email,
          verified: data.record?.verified ?? data.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' } }
    );
  }
};
