'use strict';

const assert = require('assert');
const crypto = require('crypto');
const {
  GPTPAY_BASE_URL,
  createGptPayClient,
  createCardPayIdempotencyKeys,
  assertAccountEmail,
} = require('../src/services/gptpay_service');

const KEY_ID = 'unit-test-key-id';
const API_SECRET = 'unit-test-signing-secret';
const ACCOUNT_EMAIL = 'unit.account@example.com';
const CARD_KEY = 'CARD-UNIT-FIXTURE';
const ACCESS_TOKEN = 'ACCESS-UNIT-FIXTURE';
const PREPARE_TOKEN = 'PREPARE-UNIT-FIXTURE';
const SESSION = Object.freeze({
  user: Object.freeze({ id: 'user-unit-fixture', email: ACCOUNT_EMAIL, idp: 'auth0' }),
  expires: '2099-01-01T00:00:00.000Z',
  account: Object.freeze({ id: 'account-unit-fixture', planType: 'free' }),
  accessToken: ACCESS_TOKEN,
  authProvider: 'auth0',
  sessionToken: 'SESSION-UNIT-FIXTURE',
});
const LOGIN_CONTENT = JSON.stringify(SESSION);

function response(status, payload, headers = {}) {
  const text = typeof payload === 'string' ? payload : JSON.stringify(payload);
  const normalizedHeaders = new Map(Object.entries(headers).map(([key, value]) => (
    [String(key).toLowerCase(), String(value)]
  )));
  return {
    status,
    ok: status >= 200 && status < 300,
    headers: { get: name => normalizedHeaders.get(String(name).toLowerCase()) || null },
    text: async () => text,
  };
}

function independentSignature({ method, path, timestamp, nonce, body, secret = API_SECRET }) {
  const bodyHash = crypto.createHash('sha256').update(Buffer.from(body || '', 'utf8')).digest('hex');
  const canonical = `${method}\n${path}\n${timestamp}\n${nonce}\n${bodyHash}`;
  return crypto.createHmac('sha256', secret).update(canonical, 'utf8').digest('hex');
}

async function testPrepareSignsExactJsonBytes() {
  const calls = [];
  const fetchImpl = async (url, options) => {
    calls.push({ url, options });
    return response(200, {
      success: true,
      checkout_ready: true,
      prepare_token: PREPARE_TOKEN,
      task_id: 125,
      expires_at: '2026-07-15T12:15:00+08:00',
      account_email: ACCOUNT_EMAIL,
      type: 1001,
      fulfillment_mode: 'card_pay',
    });
  };
  const client = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl,
    now: () => 1784044800000,
    nonceFactory: () => 'nonce-prepare-00000001',
    maxAttempts: 1,
  });
  const keys = createCardPayIdempotencyKeys('batch-1:item-1');
  const result = await client.prepareCardPay({
    cardKey: CARD_KEY,
    loginContent: LOGIN_CONTENT,
    expectedEmail: ACCOUNT_EMAIL.toUpperCase(),
    idempotencyKey: keys.prepare,
  });

  assert.strictEqual(calls.length, 1);
  const call = calls[0];
  assert.strictEqual(call.options.redirect, 'error', '签名请求不得自动跟随重定向');
  assert.strictEqual(Object.prototype.hasOwnProperty.call(call.options, 'dispatcher'), false);
  assert.strictEqual(Object.prototype.hasOwnProperty.call(call.options, 'agent'), false);
  assert.strictEqual(Object.prototype.hasOwnProperty.call(call.options, 'proxy'), false);
  assert.strictEqual(Object.prototype.hasOwnProperty.call(JSON.parse(call.options.body), 'proxy'), false,
    '充值请求不得读取或发送账号保存的代理');
  assert.strictEqual(call.url, `${GPTPAY_BASE_URL}/redeem/card-pay/prepare`);
  assert.strictEqual(call.options.method, 'POST');
  const expectedBody = JSON.stringify({
    card_key: CARD_KEY,
    access_token: LOGIN_CONTENT,
    idp: '',
    force_recharge: false,
    confirm_duplicate: false,
  });
  assert.strictEqual(call.options.body, expectedBody, '签名后的 JSON 字节不得再次格式化');
  assert.strictEqual(Object.prototype.hasOwnProperty.call(JSON.parse(call.options.body), 'session'), false);
  assert.deepStrictEqual(JSON.parse(JSON.parse(call.options.body).access_token), SESSION);
  assert.strictEqual(call.options.headers['X-API-Idempotency-Key'], keys.prepare);
  assert.strictEqual(call.options.headers['X-API-Signature'], independentSignature({
    method: 'POST',
    path: '/api/open/v1/redeem/card-pay/prepare',
    timestamp: call.options.headers['X-API-Timestamp'],
    nonce: call.options.headers['X-API-Nonce'],
    body: call.options.body,
  }));
  assert.strictEqual(result.taskId, '125');
  assert.strictEqual(result.accountEmail, ACCOUNT_EMAIL);
  assert.strictEqual(result.prepareToken, PREPARE_TOKEN);
}

function testStrictIdentityNormalization() {
  assert.strictEqual(
    assertAccountEmail({ account_email: 'Unit.Account@Example.com' }, ACCOUNT_EMAIL),
    ACCOUNT_EMAIL,
  );
  assert.throws(
    () => assertAccountEmail({ account_email: 'same@gmail.com' }, 'same@example.com'),
    error => error && error.code === 'GPTPAY_ACCOUNT_EMAIL_MISMATCH',
  );
  assert.strictEqual(
    assertAccountEmail({ account_email: 'firstlast@gmail.com' }, 'First.Last@gmail.com'),
    'firstlast@gmail.com',
    '主系统返回 Gmail 无点号地址时应识别为同一账号',
  );
  assert.strictEqual(
    assertAccountEmail({ account_email: 'firstlast@googlemail.com' }, 'First.Last@gmail.com'),
    'firstlast@gmail.com',
    'googlemail.com 和 gmail.com 应按同一 Gmail 域名校验',
  );
  assert.throws(
    () => assertAccountEmail({ account_email: 'firstlast@example.com' }, 'first.last@example.com'),
    error => error && error.code === 'GPTPAY_ACCOUNT_EMAIL_MISMATCH',
    '非 Gmail 邮箱不得忽略用户名中的点',
  );
  assert.throws(
    () => assertAccountEmail({ account_email: 'first.last+tag@gmail.com' }, 'first.last@gmail.com'),
    error => error && error.code === 'GPTPAY_ACCOUNT_EMAIL_MISMATCH',
    'Gmail +tag 仍需严格匹配',
  );
}

async function testRetryKeepsIdempotencyAndBodyButRefreshesSignature() {
  const calls = [];
  const replies = [
    response(503, { code: 9001, error_code: 'card_lookup_failed', request_id: 'req-1' }),
    response(200, {
      success: true,
      checkout_ready: true,
      prepare_token: PREPARE_TOKEN,
      task_id: 126,
      account_email: ACCOUNT_EMAIL,
      type: 1001,
      fulfillment_mode: 'card_pay',
    }),
  ];
  let nonceIndex = 0;
  const client = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async (url, options) => {
      calls.push({ url, options });
      return replies.shift();
    },
    now: () => 1784044800000,
    nonceFactory: () => `nonce-retry-${String(++nonceIndex).padStart(8, '0')}`,
    retryDelayMs: 0,
    maxAttempts: 2,
  });
  const key = createCardPayIdempotencyKeys('batch-1:item-2').prepare;
  await client.prepareCardPay({
    cardKey: CARD_KEY,
    loginContent: LOGIN_CONTENT,
    expectedEmail: ACCOUNT_EMAIL,
    idempotencyKey: key,
  });

  assert.strictEqual(calls.length, 2);
  assert.strictEqual(calls[0].options.body, calls[1].options.body);
  assert.strictEqual(
    calls[0].options.headers['X-API-Idempotency-Key'],
    calls[1].options.headers['X-API-Idempotency-Key'],
  );
  assert.notStrictEqual(calls[0].options.headers['X-API-Nonce'], calls[1].options.headers['X-API-Nonce']);
  assert.notStrictEqual(calls[0].options.headers['X-API-Timestamp'], calls[1].options.headers['X-API-Timestamp']);
  assert.notStrictEqual(calls[0].options.headers['X-API-Signature'], calls[1].options.headers['X-API-Signature']);
}

async function testPrepareAndConfirmUseDifferentStableKeys() {
  const keys = createCardPayIdempotencyKeys('durable-batch:item-9');
  assert(keys.prepare.startsWith('gptpay-cardprep-v2-'));
  assert(keys.confirm.startsWith('gptpay-cardconfirm-v2-'));
  assert.notStrictEqual(keys.prepare, keys.confirm);
  assert.notStrictEqual(keys.prepare, keys.prepareDuplicate);
  assert.notStrictEqual(keys.prepareDuplicate, keys.confirm);
  assert.deepStrictEqual(
    createCardPayIdempotencyKeys('durable-batch:item-9'),
    keys,
    '同一个持久化业务项必须生成相同的幂等键',
  );

  const calls = [];
  const client = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async (url, options) => {
      calls.push({ url, options });
      if (url.endsWith('/tasks/127')) {
        return response(200, {
          code: 0,
          success: true,
          task_id: 127,
          card_code: CARD_KEY,
          account: ACCOUNT_EMAIL,
          status: 'success',
          fail_reason: '',
        });
      }
      return response(200, {
        success: true,
        status: 'processing',
        task_id: 127,
        fulfillment_mode: 'card_pay',
        type: 1001,
      });
    },
    nonceFactory: () => `nonce-confirm-${String(calls.length + 1).padStart(7, '0')}`,
    maxAttempts: 1,
  });
  const result = await client.confirmCardPay({
    prepareToken: PREPARE_TOKEN,
    loginContent: LOGIN_CONTENT,
    expectedEmail: ACCOUNT_EMAIL,
    operationId: 'durable-batch:item-9',
  });
  assert.strictEqual(result.status, 'processing');
  assert.strictEqual(calls[0].options.headers['X-API-Idempotency-Key'], keys.confirm);
  assert.deepStrictEqual(JSON.parse(calls[0].options.body), {
    prepare_token: PREPARE_TOKEN,
    access_token: LOGIN_CONTENT,
    idp: '',
    force_recharge: false,
    confirm_duplicate: false,
  });
  assert.strictEqual(Object.prototype.hasOwnProperty.call(JSON.parse(calls[0].options.body), 'session'), false);

  const completed = await client.getTask({ taskId: result.taskId, expectedEmail: ACCOUNT_EMAIL });
  assert.strictEqual(completed.status, 'success');
  assert.strictEqual(completed.accountEmail, ACCOUNT_EMAIL);
  assert.strictEqual(JSON.stringify(completed).includes(CARD_KEY), false);
  assert.strictEqual(Object.prototype.hasOwnProperty.call(calls[1].options.headers, 'X-API-Idempotency-Key'), false);

  await assert.rejects(
    client.confirmCardPay({
      prepareToken: PREPARE_TOKEN,
      loginContent: LOGIN_CONTENT,
      expectedEmail: ACCOUNT_EMAIL,
      expectedTaskId: 126,
      operationId: 'durable-batch:item-9',
    }),
    error => error && error.code === 'GPTPAY_TASK_ID_MISMATCH',
  );

  await assert.rejects(
    client.prepareCardPay({
      cardKey: CARD_KEY,
      loginContent: LOGIN_CONTENT,
      idempotencyKey: keys.confirm,
    }),
    error => error && error.code === 'GPTPAY_IDEMPOTENCY_PURPOSE_CONFLICT',
  );

  await assert.rejects(
    client.prepareCardPay({
      cardKey: CARD_KEY,
      accessToken: ACCESS_TOKEN,
      operationId: 'legacy-access-token:item-1',
    }),
    error => error && error.code === 'GPTPAY_INVALID_ARGUMENT',
    '充值接口不得再接受旧的单 accessToken 入参',
  );
}

async function testDuplicateConfirmationIsTypedAndChecked() {
  const client = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async () => response(200, {
      success: false,
      requires_duplicate_confirm: true,
      duplicate_account: ACCOUNT_EMAIL,
      duplicate_redeemed_at: '2026-07-23T10:00:00+08:00',
    }),
    nonceFactory: () => 'nonce-duplicate-000001',
    maxAttempts: 1,
  });
  const result = await client.prepareCardPay({
    cardKey: CARD_KEY,
    loginContent: LOGIN_CONTENT,
    expectedEmail: ACCOUNT_EMAIL,
    operationId: 'batch-duplicate:item-1',
  });
  assert.strictEqual(result.success, false);
  assert.strictEqual(result.requiresDuplicateConfirm, true);
  assert.strictEqual(result.duplicateAccount, ACCOUNT_EMAIL);
}

async function testGetTaskUsesEmptyBodySignatureAndOmitsCardCode() {
  const calls = [];
  const client = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async (url, options) => {
      calls.push({ url, options });
      return response(200, {
        code: 0,
        success: true,
        task_id: 128,
        card_code: CARD_KEY,
        account: ACCOUNT_EMAIL,
        status: 'success',
        fail_reason: '',
        created_at: '2026-07-15T12:00:00+08:00',
        updated_at: '2026-07-15T12:00:08+08:00',
      });
    },
    now: () => 1784044802000,
    nonceFactory: () => 'nonce-task-query-00001',
    maxAttempts: 1,
  });
  const result = await client.getTask({ taskId: 128, expectedEmail: ACCOUNT_EMAIL });
  const call = calls[0];
  assert.strictEqual(call.url, `${GPTPAY_BASE_URL}/tasks/128`);
  assert.strictEqual(call.options.method, 'GET');
  assert.strictEqual(Object.prototype.hasOwnProperty.call(call.options, 'body'), false);
  assert.strictEqual(Object.prototype.hasOwnProperty.call(call.options.headers, 'Content-Type'), false);
  assert.strictEqual(Object.prototype.hasOwnProperty.call(call.options.headers, 'X-API-Idempotency-Key'), false);
  assert.strictEqual(call.options.headers['X-API-Signature'], independentSignature({
    method: 'GET',
    path: '/api/open/v1/tasks/128',
    timestamp: call.options.headers['X-API-Timestamp'],
    nonce: call.options.headers['X-API-Nonce'],
    body: '',
  }));
  assert.strictEqual(result.status, 'success');
  assert.strictEqual(result.card_code, undefined);
  assert.strictEqual(result.cardCode, undefined);
  assert.strictEqual(JSON.stringify(result).includes(CARD_KEY), false);
}

async function testTimeoutIsStrictEvenWhenFetchIgnoresAbort() {
  const client = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async () => new Promise(() => {}),
    timeoutMs: 10,
    maxAttempts: 1,
    nonceFactory: () => 'nonce-timeout-0000001',
  });
  const startedAt = Date.now();
  await assert.rejects(
    client.getTask({ taskId: 129 }),
    error => error && error.code === 'GPTPAY_TIMEOUT' && error.retryable === true,
  );
  assert(Date.now() - startedAt < 1000, '超时必须由客户端主动结束，不能依赖 fetch 自己返回');
}

async function testStrictParsingAndSafeErrors() {
  const invalidJsonClient = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async () => response(200, '<html>not json</html>'),
    maxAttempts: 1,
    nonceFactory: () => 'nonce-invalid-json-001',
  });
  await assert.rejects(
    invalidJsonClient.getTask({ taskId: 130 }),
    error => error && error.code === 'GPTPAY_RESPONSE_INVALID_JSON',
  );

  const mismatchClient = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async () => response(200, {
      success: true,
      checkout_ready: true,
      prepare_token: PREPARE_TOKEN,
      task_id: 131,
      account_email: 'different.account@example.com',
      fulfillment_mode: 'card_pay',
    }),
    maxAttempts: 1,
    nonceFactory: () => 'nonce-mismatch-0000001',
  });
  await assert.rejects(
    mismatchClient.prepareCardPay({
      cardKey: CARD_KEY,
      loginContent: LOGIN_CONTENT,
      expectedEmail: ACCOUNT_EMAIL,
      operationId: 'batch-mismatch:item-1',
    }),
    error => {
      const serialized = `${error.message} ${JSON.stringify(error)}`;
      return error.code === 'GPTPAY_ACCOUNT_EMAIL_MISMATCH'
        && error.taskId === '131'
        && !serialized.includes(ACCOUNT_EMAIL)
        && !serialized.includes('different.account@example.com')
        && !serialized.includes(CARD_KEY)
        && !serialized.includes(ACCESS_TOKEN)
        && !serialized.includes(PREPARE_TOKEN)
        && !serialized.includes(API_SECRET);
    },
  );

  const rejectedClient = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async () => response(401, {
      code: 1001,
      error_code: 'signature_invalid',
      request_id: 'safe-request-id',
      message: `${ACCESS_TOKEN} ${CARD_KEY} ${PREPARE_TOKEN} ${API_SECRET}`,
    }),
    maxAttempts: 1,
    nonceFactory: () => 'nonce-rejected-0000001',
  });
  await assert.rejects(
    rejectedClient.getTask({ taskId: 132 }),
    error => {
      const serialized = `${error.message} ${JSON.stringify(error)}`;
      return error.code === 'GPTPAY_API_REJECTED'
        && error.errorCode === 'signature_invalid'
        && !serialized.includes(ACCESS_TOKEN)
        && !serialized.includes(CARD_KEY)
        && !serialized.includes(PREPARE_TOKEN)
        && !serialized.includes(API_SECRET);
    },
  );

  const transientRejectClient = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async () => response(503, {
      code: 1503,
      error_code: 'temporarily_unavailable',
      request_id: 'safe-transient-request',
    }),
    maxAttempts: 1,
    nonceFactory: () => 'nonce-transient-000001',
  });
  await assert.rejects(
    transientRejectClient.prepareCardPay({
      cardKey: CARD_KEY,
      loginContent: LOGIN_CONTENT,
      expectedEmail: ACCOUNT_EMAIL,
      operationId: 'batch-transient:item-1',
    }),
    error => error && error.code === 'GPTPAY_API_REJECTED'
      && error.httpStatus === 503
      && error.retryable === true,
  );

  const legacyBusinessRejectClient = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async () => response(200, {
      success: false,
      error: 'fulfillment_mode_mismatch',
      request_id: 'safe-business-request',
      message: `${ACCESS_TOKEN} ${CARD_KEY} ${PREPARE_TOKEN} ${API_SECRET}`,
    }),
    maxAttempts: 1,
    nonceFactory: () => 'nonce-business-reject-001',
  });
  await assert.rejects(
    legacyBusinessRejectClient.prepareCardPay({
      cardKey: CARD_KEY,
      loginContent: LOGIN_CONTENT,
      expectedEmail: ACCOUNT_EMAIL,
      operationId: 'batch-business-reject:item-1',
    }),
    error => {
      const serialized = `${error.message} ${JSON.stringify(error)}`;
      return error.code === 'GPTPAY_BUSINESS_REJECTED'
        && error.errorCode === 'fulfillment_mode_mismatch'
        && error.requestId === 'safe-business-request'
        && !serialized.includes(ACCESS_TOKEN)
        && !serialized.includes(CARD_KEY)
        && !serialized.includes(PREPARE_TOKEN)
        && !serialized.includes(API_SECRET);
    },
  );

  assert.strictEqual(assertAccountEmail({ account_email: ACCOUNT_EMAIL }, ACCOUNT_EMAIL.toUpperCase()), ACCOUNT_EMAIL);

  const contradictoryTaskClient = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async () => response(200, {
      code: 0,
      success: true,
      task_id: 133,
      account: ACCOUNT_EMAIL,
      status: 'success',
      fail_reason: 'upstream conflict',
    }),
    maxAttempts: 1,
    nonceFactory: () => 'nonce-conflict-0000001',
  });
  await assert.rejects(
    contradictoryTaskClient.getTask({ taskId: 133, expectedEmail: ACCOUNT_EMAIL }),
    error => error && error.code === 'GPTPAY_RESPONSE_INVALID',
  );

  const contradictoryPrepareClient = createGptPayClient({
    keyId: KEY_ID,
    apiSecret: API_SECRET,
    fetchImpl: async () => response(200, {
      success: true,
      checkout_ready: true,
      prepare_token: PREPARE_TOKEN,
      task_id: 134,
      account_email: ACCOUNT_EMAIL,
      fulfillment_mode: 'card_pay',
      fail_reason: 'upstream conflict',
    }),
    maxAttempts: 1,
    nonceFactory: () => 'nonce-prepconflict-001',
  });
  await assert.rejects(
    contradictoryPrepareClient.prepareCardPay({
      cardKey: CARD_KEY,
      loginContent: LOGIN_CONTENT,
      expectedEmail: ACCOUNT_EMAIL,
      operationId: 'batch-prepconflict:item-1',
    }),
    error => error && error.code === 'GPTPAY_RESPONSE_INVALID' && error.taskId === '134',
  );
}

(async () => {
  testStrictIdentityNormalization();
  await testPrepareSignsExactJsonBytes();
  await testRetryKeepsIdempotencyAndBodyButRefreshesSignature();
  await testPrepareAndConfirmUseDifferentStableKeys();
  await testDuplicateConfirmationIsTypedAndChecked();
  await testGetTaskUsesEmptyBodySignatureAndOmitsCardCode();
  await testTimeoutIsStrictEvenWhenFetchIgnoresAbort();
  await testStrictParsingAndSafeErrors();
  console.log('gptpay_service.test.js: PASS');
})().catch(error => {
  console.error(error && error.message ? error.message : 'gptpay_service.test.js: FAIL');
  process.exitCode = 1;
});