'use strict';

const test = require('node:test');
const assert = require('node:assert/strict');
const planningDatabase = require('../src/services/planningDatabase');
const productCodeClient = require('../src/services/alibaba1688ProductCodeClient');
const encodingRegistry = require('../src/services/alibaba1688ProductEncodingRegistry');
const {
  MAX_CODING_SKUS,
  normalizeCodingRequest,
  normalizeUpstreamResult,
  encodeAlibaba1688Product,
  assertAlibaba1688PlanItemsEncoded,
} = require('../src/services/alibaba1688ProductEncodingService');

function productRecord(overrides = {}) {
  return {
    productId: '1073252781818',
    title: '实木圆桌',
    storeName: '测试家具厂',
    skuCount: 2,
    product: {
      skus: [
        {
          index: 1,
          name: '原木色 / 60cm',
          specs: [{ name: '颜色', value: '原木色' }, { name: '尺寸', value: '60cm' }],
        },
        {
          index: 2,
          name: '胡桃色 / 80cm',
          specs: [{ name: '颜色', value: '胡桃色' }, { name: '尺寸', value: '80cm' }],
        },
      ],
    },
    ...overrides,
  };
}

function codingInput(overrides = {}) {
  return {
    operationCenter: '事业二部',
    categoryName: '住宅家具 - 书架',
    taxStatus: '含税',
    invoiceType: '普票',
    installationService: '不包安装',
    installationMode: '组装',
    skuItems: [
      {
        sourceSkuKey: '1:颜色=原木色|尺寸=60cm',
        productName: '实木圆桌原木色60cm',
        colorSpec: '颜色:原木色；尺寸:60cm',
        lengthCm: 60,
        widthCm: 60,
        heightCm: 75,
      },
      {
        sourceSkuKey: '2:颜色=胡桃色|尺寸=80cm',
        productName: '实木圆桌胡桃色80cm',
        colorSpec: '颜色:胡桃色；尺寸:80cm',
        lengthCm: 80,
        widthCm: 80,
        heightCm: 75,
      },
    ],
    ...overrides,
  };
}

test('builds a server-owned coding payload with every captured SKU', () => {
  const normalized = normalizeCodingRequest(codingInput(), productRecord(), {
    id: 7,
    name: '香茗',
    departmentName: '事业二部',
  });

  assert.equal(normalized.requestPayload.ali1688ProductId, '1073252781818');
  assert.equal(normalized.requestPayload.ali1688SupplierName, '测试家具厂');
  assert.equal(normalized.requestPayload.sourceSystem, 'maixiang');
  assert.equal(normalized.requestPayload.operatorName, '香茗');
  assert.equal(normalized.requestPayload.operatorDepartment, '事业二部');
  assert.equal(normalized.requestPayload.skuItems.length, 2);
  assert.match(normalized.sourceSkus[0].sourceSkuKey, /^1:/);
});

test('rejects partial SKU submission and products above the coding limit', () => {
  assert.throws(
    () => normalizeCodingRequest(codingInput({
      skuItems: codingInput().skuItems.map((item, index) => (
        index === 0 ? { ...item, widthCm: null } : item
      )),
    }), productRecord()),
    error => error.statusCode === 400 && error.code === 'PRODUCT_CODE_SKU_DIMENSIONS_REQUIRED'
  );
  assert.throws(
    () => normalizeCodingRequest(codingInput({ skuItems: codingInput().skuItems.slice(0, 1) }), productRecord()),
    error => error.statusCode === 422 && error.code === 'PRODUCT_CODE_SKU_COUNT_MISMATCH'
  );

  const skus = Array.from({ length: MAX_CODING_SKUS + 1 }, (_, index) => ({
    index: index + 1,
    name: `规格${index + 1}`,
    specs: [{ name: '规格', value: String(index + 1) }],
  }));
  assert.throws(
    () => normalizeCodingRequest(codingInput({ skuItems: [] }), productRecord({
      skuCount: skus.length,
      product: { skus },
    })),
    error => error.statusCode === 422 && error.code === 'PRODUCT_CODE_SKU_LIMIT_EXCEEDED'
  );
  assert.throws(
    () => normalizeCodingRequest(codingInput({
      skuItems: codingInput().skuItems.map((item, index) => (
        index === 0 ? { ...item, sourceSkuKey: 'stale-key' } : item
      )),
    }), productRecord()),
    error => error.statusCode === 409 && error.code === 'PRODUCT_CODE_SKU_SNAPSHOT_CHANGED'
  );
});

test('an already encoded product returns before validating or calling the upstream API', async () => {
  let upstreamCalls = 0;
  const encoding = {
    productId: '1073252781818',
    status: 'encoded',
    styleCode: 'DF-A2SJ0094',
  };
  const result = await encodeAlibaba1688Product('1073252781818', {}, { name: '香茗' }, {
    getProduct: async () => productRecord(),
    getExistingEncoding: async () => encoding,
    createCodes: async () => {
      upstreamCalls += 1;
      throw new Error('must not be called');
    },
  });

  assert.equal(result.alreadyEncoded, true);
  assert.equal(result.encoding, encoding);
  assert.equal(upstreamCalls, 0);
});

test('maps returned product codes to source SKUs by the submitted order', () => {
  const normalized = normalizeCodingRequest(codingInput(), productRecord(), { name: '香茗' });
  const result = normalizeUpstreamResult({
    created: true,
    styleCode: 'DF-A2SJ0094',
    productCodes: ['DF-A2SJ009401', 'DF-A2SJ009402'],
    items: [
      { styleCode: 'DF-A2SJ0094', productCode: 'DF-A2SJ009401' },
      { styleCode: 'DF-A2SJ0094', productCode: 'DF-A2SJ009402' },
    ],
  }, normalized);

  assert.equal(result.productCodes.length, 2);
  assert.equal(result.skuMappings[0].sourceSkuName, '原木色 / 60cm');
  assert.equal(result.skuMappings[0].lengthCm, 60);
  assert.equal(result.skuMappings[0].heightCm, 75);
  assert.equal(result.skuMappings[1].productCode, 'DF-A2SJ009402');
  assert.throws(
    () => normalizeUpstreamResult({ productCodes: ['DF-A2SJ009401'] }, normalized),
    error => error.statusCode === 409 && error.code === 'PRODUCT_CODE_RESPONSE_COUNT_MISMATCH'
  );
  assert.throws(
    () => normalizeUpstreamResult({ productCodes: ['DF-A2SJ009401', 'DF-A2SJ009401'] }, normalized),
    error => error.statusCode === 409 && error.code === 'PRODUCT_CODE_RESPONSE_DUPLICATE'
  );
  assert.throws(
    () => normalizeUpstreamResult({
      productCodes: ['DF-A2SJ009401', 'DF-A2SJ009402'],
      items: [{ ali1688ProductId: 'different-id' }, {}],
    }, normalized),
    error => error.statusCode === 409 && error.code === 'PRODUCT_CODE_RESPONSE_PRODUCT_MISMATCH'
  );
});

test('reused upstream codes are matched by SKU name instead of response order', () => {
  const normalized = normalizeCodingRequest(codingInput(), productRecord(), { name: '香茗' });
  const result = normalizeUpstreamResult({
    created: false,
    styleCode: 'DF-A2SJ0094',
    productCodes: ['DF-A2SJ009402', 'DF-A2SJ009401'],
    items: [
      { productName: '实木圆桌胡桃色80cm', productCode: 'DF-A2SJ009402' },
      { productName: '实木圆桌原木色60cm', productCode: 'DF-A2SJ009401' },
    ],
  }, normalized);

  assert.deepEqual(result.productCodes, ['DF-A2SJ009401', 'DF-A2SJ009402']);
  assert.throws(
    () => normalizeUpstreamResult({
      created: false,
      productCodes: ['DF-A2SJ009401', 'DF-A2SJ009402'],
      items: [
        { productName: '无法匹配', productCode: 'DF-A2SJ009401' },
        { productName: '仍然无法匹配', productCode: 'DF-A2SJ009402' },
      ],
    }, normalized),
    error => error.statusCode === 409 && error.code === 'PRODUCT_CODE_REUSED_MAPPING_CONFLICT'
  );
});

test('does not call the upstream service again when the product is already encoded', async () => {
  let upstreamCalls = 0;
  const result = await encodeAlibaba1688Product('1073252781818', codingInput(), { name: '香茗' }, {
    getProduct: async () => productRecord(),
    claim: async () => ({
      claimed: false,
      record: { productId: '1073252781818', status: 'encoded', productCodes: ['DF-A2SJ009401'] },
    }),
    createCodes: async () => {
      upstreamCalls += 1;
      throw new Error('must not be called');
    },
  });

  assert.equal(result.alreadyEncoded, true);
  assert.equal(upstreamCalls, 0);
});

test('persists both newly-created and reused upstream code responses', async () => {
  for (const created of [true, false]) {
    let completed;
    const result = await encodeAlibaba1688Product('1073252781818', codingInput(), { name: '香茗' }, {
      getProduct: async () => productRecord(),
      claim: async () => ({ claimed: true, token: 'claim-token' }),
      createCodes: async () => ({
        statusCode: created ? 201 : 200,
        data: {
          created,
          matchedExisting: !created,
          styleCode: 'DF-A2SJ0094',
          productCodes: ['DF-A2SJ009401', 'DF-A2SJ009402'],
          items: created ? [] : [
            { productName: '实木圆桌原木色60cm', productCode: 'DF-A2SJ009401' },
            { productName: '实木圆桌胡桃色80cm', productCode: 'DF-A2SJ009402' },
          ],
        },
      }),
      complete: async (_productId, token, value) => {
        assert.equal(token, 'claim-token');
        completed = value;
        return { status: 'encoded', ...value };
      },
    });

    assert.equal(result.alreadyEncoded, false);
    assert.equal(result.encoding.status, 'encoded');
    assert.equal(completed.upstreamCreated, created);
    assert.equal(completed.skuMappings.length, 2);
  }
});

test('marks the result as a conflict when SKUs change during the outbound request', async () => {
  let conflict;
  await assert.rejects(
    encodeAlibaba1688Product('1073252781818', codingInput(), { name: '香茗' }, {
      getProduct: async () => productRecord(),
      getLatestProduct: async () => productRecord({
        product: {
          skus: [
            { index: 1, name: 'changed', specs: [{ name: '颜色', value: '白色' }] },
            { index: 2, name: 'changed-2', specs: [{ name: '颜色', value: '黑色' }] },
          ],
        },
      }),
      claim: async () => ({ claimed: true, token: 'claim-token' }),
      createCodes: async () => ({
        data: {
          created: true,
          styleCode: 'DF-A2SJ0094',
          productCodes: ['DF-A2SJ009401', 'DF-A2SJ009402'],
        },
      }),
      conflict: async (productId, token, error) => {
        conflict = { productId, token, code: error.code };
      },
    }),
    error => error.code === 'PRODUCT_CODE_SKU_CHANGED_DURING_ENCODING'
  );
  assert.deepEqual(conflict, {
    productId: '1073252781818',
    token: 'claim-token',
    code: 'PRODUCT_CODE_SKU_CHANGED_DURING_ENCODING',
  });
});

test('selection plans are hydrated from canonical encoded 1688 data and reject stale mappings', async () => {
  const normalized = normalizeCodingRequest(codingInput(), productRecord(), { name: '香茗' });
  const encoding = {
    status: 'encoded',
    sourceSkuCount: normalized.sourceSkus.length,
    sourceSkuFingerprint: normalized.sourceSkuFingerprint,
    productCodes: ['DF-A2SJ009401', 'DF-A2SJ009402'],
    skuMappings: normalized.sourceSkus.map((entry, index) => ({
      sourceSkuKey: entry.sourceSkuKey,
      productCode: `DF-A2SJ00940${index + 1}`,
    })),
  };
  const rows = await assertAlibaba1688PlanItemsEncoded([
    { marketItemId: '1073252781818', channelName: '1688', sourceRow: { untrusted: true } },
  ], {
    getProduct: async () => ({
      ...productRecord(),
      skuFingerprint: normalized.sourceSkuFingerprint,
    }),
    getEncoding: async () => encoding,
  });
  assert.equal(rows[0].channelName, '1688');
  assert.deepEqual(rows[0].sourceRow.encoding.skuMappings, encoding.skuMappings);
  assert.equal(rows[0].sourceRow.source, 'alibaba_1688_products');

  await assert.rejects(
    assertAlibaba1688PlanItemsEncoded([{ marketItemId: '1073252781818', channelName: '1688' }], {
      getProduct: async () => ({ ...productRecord(), skuFingerprint: 'changed-fingerprint' }),
      getEncoding: async () => encoding,
    }),
    error => error.code === 'ALIBABA_1688_PRODUCT_ENCODING_STALE'
  );

  let ordinaryLookupCount = 0;
  const ordinaryRows = await assertAlibaba1688PlanItemsEncoded([
    { marketItemId: '1073252781818', channelName: '拼多多' },
  ], {
    getProduct: async () => {
      ordinaryLookupCount += 1;
      return productRecord();
    },
  });
  assert.equal(ordinaryLookupCount, 0);
  assert.equal(ordinaryRows[0].channelName, '拼多多');
});

test('records a failed claim without retrying the upstream request', async () => {
  let upstreamCalls = 0;
  let failed;
  await assert.rejects(
    encodeAlibaba1688Product('1073252781818', codingInput(), { name: '香茗' }, {
      getProduct: async () => productRecord(),
      claim: async () => ({ claimed: true, token: 'claim-token' }),
      createCodes: async () => {
        upstreamCalls += 1;
        throw Object.assign(new Error('upstream timeout'), { statusCode: 504 });
      },
      fail: async (productId, token, error) => {
        failed = { productId, token, message: error.message };
      },
    }),
    /upstream timeout/
  );
  assert.equal(upstreamCalls, 1);
  assert.deepEqual(failed, {
    productId: '1073252781818',
    token: 'claim-token',
    message: 'upstream timeout',
  });
});

test('the outbound client keeps the API key in a backend request header', async () => {
  const previous = {
    key: process.env.PRODUCT_CODE_API_KEY,
    baseUrl: process.env.PRODUCT_CODE_API_BASE_URL,
    timeout: process.env.PRODUCT_CODE_API_TIMEOUT_MS,
  };
  process.env.PRODUCT_CODE_API_KEY = 'server-only-test-key';
  process.env.PRODUCT_CODE_API_BASE_URL = 'https://yyd.jiansuntuzhi.cn';
  process.env.PRODUCT_CODE_API_TIMEOUT_MS = '31000';
  let requestConfig;
  try {
    const response = await productCodeClient.getProductCodeMeta({
      httpClient: async (config) => {
        requestConfig = config;
        return { status: 200, data: { success: true, data: { operationCenters: [] } } };
      },
    });
    assert.deepEqual(response.data.operationCenters, []);
    assert.equal(requestConfig.headers['X-API-Key'], 'server-only-test-key');
    assert.equal(requestConfig.timeout, 31000);
    assert.equal(requestConfig.url, 'https://yyd.jiansuntuzhi.cn/api/public/product-code-board/meta');
  } finally {
    if (previous.key === undefined) delete process.env.PRODUCT_CODE_API_KEY;
    else process.env.PRODUCT_CODE_API_KEY = previous.key;
    if (previous.baseUrl === undefined) delete process.env.PRODUCT_CODE_API_BASE_URL;
    else process.env.PRODUCT_CODE_API_BASE_URL = previous.baseUrl;
    if (previous.timeout === undefined) delete process.env.PRODUCT_CODE_API_TIMEOUT_MS;
    else process.env.PRODUCT_CODE_API_TIMEOUT_MS = previous.timeout;
  }
});

test('the outbound client refuses to run without a server-side API key', () => {
  const previous = process.env.PRODUCT_CODE_API_KEY;
  delete process.env.PRODUCT_CODE_API_KEY;
  try {
    assert.throws(
      () => productCodeClient.getProductCodeApiConfig(),
      error => error.statusCode === 503 && error.code === 'PRODUCT_CODE_API_KEY_MISSING'
    );
  } finally {
    if (previous === undefined) delete process.env.PRODUCT_CODE_API_KEY;
    else process.env.PRODUCT_CODE_API_KEY = previous;
  }
});

test('an existing encoded registry row wins a duplicate insert race', async () => {
  const originalExecute = planningDatabase.execute;
  const originalQuery = planningDatabase.query;
  let encodingLookupCount = 0;
  planningDatabase.execute = async (sql) => {
    if (sql.startsWith('CREATE TABLE')) return { affectedRows: 0 };
    if (sql.startsWith('INSERT INTO')) {
      throw Object.assign(new Error('duplicate'), { code: 'ER_DUP_ENTRY', errno: 1062 });
    }
    throw new Error(`unexpected SQL: ${sql}`);
  };
  planningDatabase.query = async (sql) => {
    if (sql.includes('information_schema.tables')) return [{ ok: 1 }];
    if (sql.includes('information_schema.columns')) {
      return [{ column_name: 'source_sku_count' }, { column_name: 'source_sku_fingerprint' }];
    }
    encodingLookupCount += 1;
    if (encodingLookupCount === 1) return [];
    return [{
      product_id: '1073252781818',
      status: 'encoded',
      style_code: 'DF-A2SJ0094',
      style_codes_json: '["DF-A2SJ0094"]',
      product_codes_json: '["DF-A2SJ009401"]',
      sku_mapping_json: '[]',
      source_sku_count: 1,
      source_sku_fingerprint: 'fingerprint',
      attempt_count: 1,
    }];
  };

  try {
    const normalized = normalizeCodingRequest(codingInput(), productRecord());
    const result = await encodingRegistry.claimEncoding(
      '1073252781818',
      normalized.requestPayload,
      { name: '香茗' },
      {
        sourceSkuCount: normalized.sourceSkus.length,
        sourceSkuFingerprint: normalized.sourceSkuFingerprint,
      }
    );
    assert.equal(result.claimed, false);
    assert.equal(result.record.status, 'encoded');
    assert.deepEqual(result.record.productCodes, ['DF-A2SJ009401']);
  } finally {
    planningDatabase.execute = originalExecute;
    planningDatabase.query = originalQuery;
  }
});

test('the claim lease always exceeds the configured outbound timeout', () => {
  const previousTimeout = process.env.PRODUCT_CODE_API_TIMEOUT_MS;
  const previousTtl = process.env.PRODUCT_CODE_CLAIM_TTL_SECONDS;
  process.env.PRODUCT_CODE_API_TIMEOUT_MS = '120000';
  process.env.PRODUCT_CODE_CLAIM_TTL_SECONDS = '120';
  try {
    assert.equal(encodingRegistry.getClaimTtlSeconds(), 180);
  } finally {
    if (previousTimeout === undefined) delete process.env.PRODUCT_CODE_API_TIMEOUT_MS;
    else process.env.PRODUCT_CODE_API_TIMEOUT_MS = previousTimeout;
    if (previousTtl === undefined) delete process.env.PRODUCT_CODE_CLAIM_TTL_SECONDS;
    else process.env.PRODUCT_CODE_CLAIM_TTL_SECONDS = previousTtl;
  }
});

test('retry comparison preserves the first business request while allowing a different operator', () => {
  const original = {
    ...codingInput(),
    operatorName: '香茗',
    operatorDepartment: '事业二部',
  };
  const sameBusiness = {
    ...codingInput(),
    operatorName: '管理员',
    operatorDepartment: '系统管理',
  };
  assert.equal(
    encodingRegistry.retryComparableRequest(original),
    encodingRegistry.retryComparableRequest(sameBusiness)
  );
  assert.notEqual(
    encodingRegistry.retryComparableRequest(original),
    encodingRegistry.retryComparableRequest({
      ...sameBusiness,
      categoryName: '住宅家具 - 电脑桌',
    })
  );
});

test('legacy failed requests may fill only missing dimensions while preserving the first request', () => {
  const normalized = normalizeCodingRequest(codingInput(), productRecord(), {
    name: 'first-operator',
    departmentName: 'first-department',
  });
  const legacyRequest = JSON.parse(JSON.stringify(normalized.requestPayload));
  delete legacyRequest.skuItems[0].lengthCm;
  legacyRequest.skuItems[0].widthCm = null;
  delete legacyRequest.skuItems[1].heightCm;

  const incoming = {
    ...normalized.requestPayload,
    operatorName: 'retry-operator',
    operatorDepartment: 'retry-department',
  };
  const upgraded = encodingRegistry.reconcileRetryRequest(legacyRequest, incoming);
  assert.equal(upgraded.operatorName, 'first-operator');
  assert.equal(upgraded.skuItems[0].lengthCm, 60);
  assert.equal(upgraded.skuItems[0].widthCm, 60);
  assert.equal(upgraded.skuItems[1].heightCm, 75);

  assert.throws(
    () => encodingRegistry.reconcileRetryRequest(normalized.requestPayload, {
      ...incoming,
      skuItems: incoming.skuItems.map((item, index) => (
        index === 0 ? { ...item, lengthCm: 61 } : item
      )),
    }),
    error => error.code === 'PRODUCT_ENCODING_RETRY_REQUEST_CHANGED'
  );
  assert.throws(
    () => encodingRegistry.reconcileRetryRequest(legacyRequest, {
      ...incoming,
      skuItems: incoming.skuItems.map((item, index) => (
        index === 0 ? { ...item, productName: 'changed-name' } : item
      )),
    }),
    error => error.code === 'PRODUCT_ENCODING_RETRY_REQUEST_CHANGED'
  );
});

test('source snapshots require the full request count and a SHA-256 fingerprint', () => {
  const normalized = normalizeCodingRequest(codingInput(), productRecord());
  assert.deepEqual(
    encodingRegistry.normalizeSourceSnapshot({
      sourceSkuCount: normalized.sourceSkus.length,
      sourceSkuFingerprint: normalized.sourceSkuFingerprint,
    }, normalized.requestPayload),
    {
      sourceSkuCount: 2,
      sourceSkuFingerprint: normalized.sourceSkuFingerprint,
    }
  );
  assert.throws(
    () => encodingRegistry.normalizeSourceSnapshot({
      sourceSkuCount: 1,
      sourceSkuFingerprint: normalized.sourceSkuFingerprint,
    }, normalized.requestPayload),
    error => error.code === 'PRODUCT_ENCODING_SOURCE_SKU_CHANGED'
  );
  assert.throws(
    () => encodingRegistry.normalizeSourceSnapshot({
      sourceSkuCount: 2,
      sourceSkuFingerprint: 'not-a-fingerprint',
    }, normalized.requestPayload),
    error => error.code === 'PRODUCT_ENCODING_SOURCE_SNAPSHOT_REQUIRED'
  );
});

test('the first registry claim persists the SKU count and fingerprint in the insert', async () => {
  const normalized = normalizeCodingRequest(codingInput(), productRecord());
  const originalExecute = planningDatabase.execute;
  const originalQuery = planningDatabase.query;
  let inserted = false;
  let insertSql = '';
  let insertParams = [];
  planningDatabase.query = async (sql) => {
    if (sql.includes('information_schema.tables')) return [{ ok: 1 }];
    if (sql.includes('information_schema.columns')) {
      return [{ column_name: 'source_sku_count' }, { column_name: 'source_sku_fingerprint' }];
    }
    if (sql.includes('SELECT * FROM alibaba_1688_product_encodings')) {
      if (!inserted) return [];
      return [{
        product_id: productRecord().productId,
        status: 'encoding',
        request_json: JSON.stringify(normalized.requestPayload),
        source_sku_count: normalized.sourceSkus.length,
        source_sku_fingerprint: normalized.sourceSkuFingerprint,
        attempt_count: 1,
      }];
    }
    throw new Error(`unexpected SQL: ${sql}`);
  };
  planningDatabase.execute = async (sql, params) => {
    if (sql.includes('INSERT INTO alibaba_1688_product_encodings')) {
      inserted = true;
      insertSql = sql;
      insertParams = params;
      return { affectedRows: 1 };
    }
    throw new Error(`unexpected SQL: ${sql}`);
  };

  try {
    const result = await encodingRegistry.claimEncoding(
      productRecord().productId,
      normalized.requestPayload,
      {},
      {
        sourceSkuCount: normalized.sourceSkus.length,
        sourceSkuFingerprint: normalized.sourceSkuFingerprint,
      }
    );
    assert.equal(result.claimed, true);
    assert.match(insertSql, /source_sku_count, source_sku_fingerprint/);
    assert.equal(insertParams[3], normalized.sourceSkus.length);
    assert.equal(insertParams[4], normalized.sourceSkuFingerprint);
  } finally {
    planningDatabase.execute = originalExecute;
    planningDatabase.query = originalQuery;
  }
});

test('a retry claim atomically upgrades only legacy missing dimensions and rejects a changed fingerprint', async () => {
  const normalized = normalizeCodingRequest(codingInput(), productRecord());
  const legacyRequest = JSON.parse(JSON.stringify(normalized.requestPayload));
  delete legacyRequest.skuItems[0].lengthCm;
  legacyRequest.skuItems[0].widthCm = null;
  const originalExecute = planningDatabase.execute;
  const originalQuery = planningDatabase.query;
  let storedFingerprint = null;
  let updateSql = '';
  let updateParams = [];
  let updateCount = 0;
  planningDatabase.query = async (sql) => {
    if (sql.includes('information_schema.tables')) return [{ ok: 1 }];
    if (sql.includes('information_schema.columns')) {
      return [{ column_name: 'source_sku_count' }, { column_name: 'source_sku_fingerprint' }];
    }
    if (sql.includes('SELECT * FROM alibaba_1688_product_encodings')) {
      return [{
        product_id: productRecord().productId,
        status: 'failed',
        request_json: JSON.stringify(legacyRequest),
        source_sku_count: null,
        source_sku_fingerprint: storedFingerprint,
        attempt_count: 1,
      }];
    }
    throw new Error(`unexpected SQL: ${sql}`);
  };
  planningDatabase.execute = async (sql, params) => {
    if (sql.includes('INSERT INTO alibaba_1688_product_encodings')) {
      throw Object.assign(new Error('duplicate'), { code: 'ER_DUP_ENTRY', errno: 1062 });
    }
    if (sql.includes('UPDATE alibaba_1688_product_encodings')) {
      updateCount += 1;
      updateSql = sql;
      updateParams = params;
      return { affectedRows: 1 };
    }
    throw new Error(`unexpected SQL: ${sql}`);
  };

  const snapshot = {
    sourceSkuCount: normalized.sourceSkus.length,
    sourceSkuFingerprint: normalized.sourceSkuFingerprint,
  };
  try {
    const result = await encodingRegistry.claimEncoding(
      productRecord().productId,
      normalized.requestPayload,
      {},
      snapshot
    );
    assert.equal(result.claimed, true);
    assert.equal(result.requestPayload.skuItems[0].lengthCm, 60);
    assert.equal(result.requestPayload.skuItems[0].widthCm, 60);
    assert.match(updateSql, /source_sku_count IS NULL OR source_sku_count = \?/);
    assert.match(updateSql, /source_sku_fingerprint IS NULL OR source_sku_fingerprint = \?/);
    assert.equal(updateParams[2], snapshot.sourceSkuCount);
    assert.equal(updateParams[3], snapshot.sourceSkuFingerprint);

    storedFingerprint = 'a'.repeat(64);
    await assert.rejects(
      encodingRegistry.claimEncoding(
        productRecord().productId,
        normalized.requestPayload,
        {},
        snapshot
      ),
      error => error.code === 'PRODUCT_ENCODING_SOURCE_SKU_CHANGED'
    );
    assert.equal(updateCount, 1);
  } finally {
    planningDatabase.execute = originalExecute;
    planningDatabase.query = originalQuery;
  }
});

test('selection plans reject incomplete, duplicate or mismatched encoded SKU mappings', async () => {
  const normalized = normalizeCodingRequest(codingInput(), productRecord());
  const product = {
    ...productRecord(),
    skuFingerprint: normalized.sourceSkuFingerprint,
  };
  const validEncoding = {
    status: 'encoded',
    sourceSkuCount: 2,
    sourceSkuFingerprint: normalized.sourceSkuFingerprint,
    productCodes: ['CODE-1', 'CODE-2'],
    skuMappings: normalized.sourceSkus.map((entry, index) => ({
      sourceSkuKey: entry.sourceSkuKey,
      productCode: `CODE-${index + 1}`,
    })),
  };
  const invalidEncodings = [
    { ...validEncoding, sourceSkuCount: 1 },
    { ...validEncoding, productCodes: ['CODE-1'] },
    { ...validEncoding, productCodes: ['CODE-1', 'CODE-1'] },
    { ...validEncoding, skuMappings: validEncoding.skuMappings.slice(0, 1) },
    {
      ...validEncoding,
      skuMappings: validEncoding.skuMappings.map(mapping => ({
        ...mapping,
        sourceSkuKey: validEncoding.skuMappings[0].sourceSkuKey,
      })),
    },
    {
      ...validEncoding,
      skuMappings: validEncoding.skuMappings.map((mapping, index) => (
        index === 0 ? { ...mapping, productCode: 'UNKNOWN-CODE' } : mapping
      )),
    },
  ];

  for (const encoding of invalidEncodings) {
    await assert.rejects(
      assertAlibaba1688PlanItemsEncoded([
        { marketItemId: product.productId, channelName: '1688' },
      ], {
        getProduct: async () => product,
        getEncoding: async () => encoding,
      }),
      error => error.code === 'ALIBABA_1688_PRODUCT_ENCODING_STALE'
    );
  }
});