'use strict';

function normalizeToken(value) {
   return String(value || '').trim();
}

function getToken(ctx) {
   const query = ctx?.query || ctx?.request?.query || {};
   const header = ctx?.header || ctx?.headers || ctx?.request?.header || ctx?.request?.headers || {};
   const authHeader = normalizeToken(header.authorization || header.Authorization);
   if (authHeader) {
      return normalizeToken(authHeader.replace(/^Bearer\s+/i, ''));
   }
   if (header.token) return normalizeToken(header.token);
   if (query.token) return normalizeToken(query.token);
   return '';
}

function getVerifyTokenPaths(ctx) {
   const configuredPath = ctx?.app?.fs?.config?.tenderUser?.aiCenter?.verifyTokenPath || '/verify-token';
   return String(configuredPath || '').trim() || '/verify-token';
}

function resolveCenterVerifyUser(centerResponse) {
   if (!centerResponse || typeof centerResponse !== 'object') return null;
   const userInfo = centerResponse?.AIUserInfo
      || centerResponse?.data?.AIUserInfo
      || centerResponse?.userInfo
      || centerResponse?.data?.userInfo
      || centerResponse?.data
      || centerResponse;
   if (!userInfo || typeof userInfo !== 'object') return null;
   const userId = String(
      userInfo?.pepUserId
      || userInfo?.pep_user_id
      || userInfo?.pepId
      || userInfo?.pep_id
      || userInfo?.id
      || userInfo?.userId
      || '',
   ).trim();
   if (!userId) return null;
   return userInfo;
}

async function verifyByAiCenter(ctx, token) {
   const centerRequest = ctx?.app?.fs?.centerRequest;
   if (!centerRequest) {
      return null;
   }

   const path = getVerifyTokenPaths(ctx);
   try {
      const centerResponse = await centerRequest.get(path, { query: { token } });
      const userInfo = resolveCenterVerifyUser(centerResponse);
      if (userInfo) {
         return userInfo;
      }
   } catch (error) {
      const logger = ctx.fs?.logger || ctx.logger || console;
      logger.warn(`[AUTH] Center token verify failed on ${path}: ${error?.message || error}`);
      return null;
   }
   return null;
}

module.exports = async (ctx, next) => {
   ctx.fs = ctx.fs || {};
   const { path } = ctx;
   if (path) {
      try {
         const token = getToken(ctx);

         if (!token) {
            ctx.throw(401, 'Unauthorized');
            return;
         }

         const userInfo = await verifyByAiCenter(ctx, token);

         if (!userInfo) {
            ctx.throw(401, 'Unauthorized');
            return;
         }

         ctx.fs.curUser = {
            token,
            userInfo,
         };
         await next();
      } catch (error) {
         ctx.logger.error(error);
         ctx.throw(error.status || 401, error.message || error);
      }
   } else {
      await next();
   }
}