// ============================================================================
// CWR BYTE-DIFF — strict per-society spec compliance auditor
//
// For each society, we hold a "expected layout" — for every record type,
// the exact field positions, lengths, and value rules per CWR spec + society
// supplements. This module runs a built transmission against the layout
// and reports every byte-level divergence.
//
// This is the work that turns "looks plausible" into "byte-equality with the
// CISAC validator". One society at a time.
//
// EXPORT: window.CwrByteDiff = { auditTransmission, SOCIETY_LAYOUTS }
// ============================================================================
(function () {
  // ────────────────────────────────────────────────────────────────────────
  // Field-level spec for every record type, parameterised by version.
  // Each entry is { name, start, length, type, valid? }
  //   type: 'AN' (alphanumeric), 'A' (alpha), 'N' (numeric), 'D' (date YYYYMMDD),
  //         'T' (time HHMMSS), 'B' (boolean Y/N), 'F' (flag/code list)
  //   valid: optional array of allowed values for F type
  // ────────────────────────────────────────────────────────────────────────

  const FIELD_SPECS = {
    HDR: (v) => [
      { name: 'recordType', start: 0, length: 3, type: 'F', valid: ['HDR'] },
      { name: 'senderType', start: 3, length: 2, type: 'F', valid: ['SO','PB','WR','AA'] },
      { name: 'senderId', start: 5, length: 9, type: 'AN' },
      { name: 'senderName', start: 14, length: 45, type: 'AN' },
      { name: 'ediVersion', start: 59, length: 5, type: 'AN' },
      { name: 'creationDate', start: 64, length: 8, type: 'D' },
      { name: 'creationTime', start: 72, length: 6, type: 'T' },
      { name: 'transmissionDate', start: 78, length: 8, type: 'D' },
    ],
    GRH: (v) => [
      { name: 'recordType', start: 0, length: 3, type: 'F', valid: ['GRH'] },
      { name: 'transactionType', start: 3, length: 3, type: 'F', valid: ['NWR','REV','ISW','EXC','ACK','AGR'] },
      { name: 'groupId', start: 6, length: 5, type: 'N' },
      { name: 'versionNumber', start: 11, length: 5, type: 'AN' },
    ],
    GRT: (v) => [
      { name: 'recordType', start: 0, length: 3, type: 'F', valid: ['GRT'] },
      { name: 'groupId', start: 3, length: 5, type: 'N' },
      { name: 'transactionCount', start: 8, length: 8, type: 'N' },
      // CWR spec: GRT recordCount is 7 chars (total length 23) across all versions
      { name: 'recordCount', start: 16, length: 7, type: 'N' },
    ],
    TRL: (v) => [
      { name: 'recordType', start: 0, length: 3, type: 'F', valid: ['TRL'] },
      { name: 'groupCount', start: 3, length: 5, type: 'N' },
      { name: 'transactionCount', start: 8, length: 8, type: 'N' },
      { name: 'recordCount', start: 16, length: 7, type: 'N' },
    ],
    NWR: (v) => [
      { name: 'recordType', start: 0, length: 3, type: 'F', valid: ['NWR','REV','ISW','EXC'] },
      { name: 'transactionSeq', start: 3, length: 8, type: 'N' },
      { name: 'recordSeq', start: 11, length: 8, type: 'N' },
      { name: 'workTitle', start: 19, length: 60, type: 'AN' },
      { name: 'languageCode', start: 79, length: 2, type: 'AN' },
      { name: 'submitterWorkNum', start: 81, length: 14, type: 'AN' },
      { name: 'iswc', start: 95, length: 11, type: 'AN' },
      { name: 'copyrightDate', start: 106, length: 8, type: 'D' },
    ],
    SPU: (v) => [
      { name: 'recordType', start: 0, length: 3, type: 'F', valid: ['SPU','OPU'] },
      { name: 'transactionSeq', start: 3, length: 8, type: 'N' },
      { name: 'recordSeq', start: 11, length: 8, type: 'N' },
      { name: 'publisherSequenceNum', start: 19, length: 2, type: 'N' },
      { name: 'interestedPartyNum', start: 21, length: 9, type: 'AN' },
      { name: 'publisherName', start: 30, length: 45, type: 'AN' },
      { name: 'publisherUnknown', start: 75, length: 1, type: 'F', valid: [' ','Y','N'] },
      { name: 'publisherType', start: 76, length: 2, type: 'F', valid: ['  ','AM','AQ','E ','ES','OP','PA','SE'] },
      { name: 'taxId', start: 78, length: 9, type: 'AN' },
      { name: 'ipiName', start: 87, length: 11, type: 'AN' },
    ],
    SWR: (v) => [
      { name: 'recordType', start: 0, length: 3, type: 'F', valid: ['SWR','OWR'] },
      { name: 'transactionSeq', start: 3, length: 8, type: 'N' },
      { name: 'recordSeq', start: 11, length: 8, type: 'N' },
      { name: 'interestedPartyNum', start: 19, length: 9, type: 'AN' },
      { name: 'writerLastName', start: 28, length: 45, type: 'AN' },
      { name: 'writerFirstName', start: 73, length: 30, type: 'AN' },
      { name: 'writerUnknown', start: 103, length: 1, type: 'F', valid: [' ','Y','N'] },
      { name: 'writerDesignation', start: 104, length: 2, type: 'F', valid: ['  ','AD','AR','A ','C ','CA','SA','SR','TR'] },
      { name: 'taxId', start: 106, length: 9, type: 'AN' },
    ],
    PER: (v) => [
      { name: 'recordType', start: 0, length: 3, type: 'F', valid: ['PER'] },
      { name: 'transactionSeq', start: 3, length: 8, type: 'N' },
      { name: 'recordSeq', start: 11, length: 8, type: 'N' },
      { name: 'lastName', start: 19, length: 45, type: 'AN' },
      { name: 'firstName', start: 64, length: 30, type: 'AN' },
      { name: 'ipiName', start: 94, length: 11, type: 'AN' },
      ...(v === '2.2' || v === '3.0' || v === '3.1' ? [
        { name: 'ipiBase', start: 105, length: 13, type: 'AN' },
      ] : []),
      ...(v === '3.0' || v === '3.1' ? [
        { name: 'performanceLanguage', start: 118, length: 2, type: 'AN' },
        { name: 'performanceDialect', start: 120, length: 3, type: 'AN' },
      ] : []),
    ],
    ORN: (v) => [
      { name: 'recordType', start: 0, length: 3, type: 'F', valid: ['ORN'] },
      { name: 'transactionSeq', start: 3, length: 8, type: 'N' },
      { name: 'recordSeq', start: 11, length: 8, type: 'N' },
      { name: 'intendedPurpose', start: 19, length: 3, type: 'F', valid: ['COM','FIL','LIB','MUL','RAD','TEL','THR','VID'] },
      { name: 'productionTitle', start: 22, length: 60, type: 'AN' },
      { name: 'cdIdentifier', start: 82, length: 15, type: 'AN' },
      { name: 'cutNumber', start: 97, length: 4, type: 'AN' },
      // 2.1: jumps directly to BLTVR after cutNumber. 2.2+: library 60 chars.
      ...(v === '2.2' || v === '3.0' || v === '3.1' ? [
        { name: 'library', start: 101, length: 60, type: 'AN' },
        { name: 'bltvr', start: 161, length: 1, type: 'F', valid: [' ','B','L','T','V','R'] },
        { name: 'visan', start: 162, length: 25, type: 'AN' },
        { name: 'productionNum', start: 187, length: 12, type: 'AN' },
        { name: 'episodeTitle', start: 199, length: 60, type: 'AN' },
        { name: 'episodeNum', start: 259, length: 20, type: 'AN' },
        { name: 'productionYear', start: 279, length: 4, type: 'AN' },
        { name: 'aviSocietyCode', start: 283, length: 3, type: 'AN' },
        { name: 'audioVisualNumber', start: 286, length: 15, type: 'AN' },
      ] : [
        { name: 'bltvr', start: 101, length: 1, type: 'F', valid: [' ','B','L','T','V','R'] },
        { name: 'visan', start: 102, length: 25, type: 'AN' },
        { name: 'productionNum', start: 127, length: 12, type: 'AN' },
        { name: 'productionYear', start: 139, length: 4, type: 'AN' },
        { name: 'aviSocietyCode', start: 143, length: 3, type: 'AN' },
        { name: 'audioVisualNumber', start: 146, length: 15, type: 'AN' },
      ]),
    ],
    XRF: (v) => [
      { name: 'recordType', start: 0, length: 3, type: 'F', valid: ['XRF'] },
      { name: 'transactionSeq', start: 3, length: 8, type: 'N' },
      { name: 'recordSeq', start: 11, length: 8, type: 'N' },
      { name: 'organisationCode', start: 19, length: 3, type: 'N' },
      { name: 'identifier', start: 22, length: 14, type: 'AN' },
      { name: 'identifierType', start: 36, length: 1, type: 'F', valid: ['W','R','P','V','T','X','S','A','I','M','U'] },
      { name: 'validityIndicator', start: 37, length: 1, type: 'F', valid: ['Y','N','U'] },
    ],
  };

  // ────────────────────────────────────────────────────────────────────────
  // SOCIETY LAYOUTS — per-society overlays.
  // Most fields are per-spec; societies have specific MUST-HAVE rules and
  // value restrictions. Each entry says "for this society, this field must
  // satisfy this constraint at the byte level".
  // ────────────────────────────────────────────────────────────────────────

  const SOCIETY_LAYOUTS = {
    ASCAP: {
      cisac: '010',
      country: 'US',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SPT','SWR','SWT','PWR','GRT','TRL'],
      fieldConstraints: {
        // ASCAP requires non-blank submitter publisher number on every SPU
        SPU: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'ASCAP requires interested party number on every SPU' },
          // ASCAP Type-of-Income flag — ascertain publisher type is set
          { field: 'publisherType', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'ASCAP requires publisher type code (E/AM/PA/etc.)' },
        ],
        // ASCAP requires PWR (publisher-for-writer) for every SWR with controlled publisher
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'ASCAP requires writer interested party number' },
          { field: 'writerDesignation', rule: 'in-list',
            check: (val) => ['CA','C ','A ','SR','SA','TR'].includes(val),
            message: 'ASCAP writer designation must be CA/C/A/SR/SA/TR' },
        ],
        NWR: [
          { field: 'workTitle', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'ASCAP work title is required' },
        ],
      },
      crossRecord: [
        { name: 'Every controlled SWR has a matching PWR',
          check: (lines) => {
            const swrs = lines.filter(l => l.startsWith('SWR'));
            const pwrs = lines.filter(l => l.startsWith('PWR'));
            return swrs.length === 0 || pwrs.length >= swrs.length;
          } },
      ],
    },

    BMI: {
      cisac: '021',
      country: 'US',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SPU: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'BMI requires interested party number on SPU' },
          // BMI: submitter publisher number required (taxId field)
          { field: 'taxId', rule: 'present-or-name',
            check: (val) => true, // taxId can be blank if publisher name present; we check at SPU level later
            message: 'BMI: submitter publisher tax ID expected' },
        ],
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'BMI requires writer interested party number' },
        ],
      },
      crossRecord: [],
    },

    PRS: {
      cisac: '052',
      country: 'GB',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        // PRS requires ORN first-use date for library/AV usage
        ORN: [
          { field: 'productionYear', rule: 'numeric-or-blank',
            check: (val) => /^\d{4}$/.test(val) || val.trim() === '',
            message: 'PRS requires 4-digit production year on ORN' },
          { field: 'intendedPurpose', rule: 'in-list',
            check: (val) => ['COM','FIL','LIB','MUL','RAD','TEL','THR','VID'].includes(val),
            message: 'PRS strict ORN intended purpose validation' },
        ],
      },
      crossRecord: [],
    },

    GEMA: {
      cisac: '035',
      country: 'DE',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'GEMA requires writer IPN' },
        ],
      },
      crossRecord: [
        { name: 'GEMA: NCT must accompany titles with non-ASCII chars',
          check: (lines) => {
            const nct = lines.some(l => l.startsWith('NCT'));
            const nonAscii = lines.some(l => /[^\x00-\x7F]/.test(l));
            return nonAscii ? nct : true;
          } },
      ],
    },

    SACEM: {
      cisac: '058',
      country: 'FR',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'SACEM requires writer IPN' },
          { field: 'writerDesignation', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'SACEM requires writer designation auto-filled from role' },
        ],
      },
      crossRecord: [],
    },

    JASRAC: {
      cisac: '101',
      country: 'JP',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        NWR: [
          { field: 'workTitle', rule: 'ascii-only',
            check: (val) => !/[^\x00-\x7F]/.test(val),
            message: 'JASRAC: NWR title must be ASCII; non-Roman in NCT' },
        ],
      },
      crossRecord: [
        { name: 'JASRAC: non-Roman titles → require NCT companion',
          check: (lines) => {
            // If submitter input had Japanese, builder should auto-emit NCT
            return true; // builder enforces this; placeholder for tighter check
          } },
      ],
    },

    SESAC: {
      cisac: '071',
      country: 'US',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SPU: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'SESAC: interested party number required on SPU' },
        ],
        SWR: [
          { field: 'writerDesignation', rule: 'in-list',
            check: (val) => ['CA','C ','A ','SR','SA','TR'].includes(val),
            message: 'SESAC: writer designation must be CA/C/A/SR/SA/TR' },
        ],
      },
      crossRecord: [],
    },

    GMR: {
      cisac: '170',
      country: 'US',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'GMR: writer IPN required' },
        ],
      },
      crossRecord: [],
    },

    SOCAN: {
      cisac: '055',
      country: 'CA',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'SOCAN: writer IPN required' },
        ],
        SPU: [
          { field: 'publisherType', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'SOCAN: publisher type required' },
        ],
      },
      crossRecord: [],
    },

    APRA_AMCOS: {
      cisac: '040',
      country: 'AU',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'APRA AMCOS: writer IPN required' },
        ],
      },
      crossRecord: [],
    },

    STIM: {
      cisac: '079',
      country: 'SE',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'STIM: writer IPN required' },
        ],
      },
      crossRecord: [],
    },

    SIAE: {
      cisac: '062',
      country: 'IT',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'SIAE: writer IPN required' },
          { field: 'writerDesignation', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'SIAE: writer designation required' },
        ],
      },
      crossRecord: [],
    },

    AKM: {
      cisac: '005',
      country: 'AT',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'AKM: writer IPN required' },
        ],
      },
      crossRecord: [],
    },

    MLC: {
      cisac: '775', // MLC is US mech-only collective; not a CISAC PRO but uses CWR
      country: 'US',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SPU: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'MLC: publisher IPN required (mechanical-only)' },
        ],
        // MLC focuses on MR shares — PR shares may be 0
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'MLC: writer IPN required' },
        ],
      },
      crossRecord: [],
    },

    HFA: {
      cisac: '999', // HFA is US licensing agent; uses CWR-derived format
      country: 'US',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SPU: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'HFA: publisher IPN required' },
        ],
      },
      crossRecord: [],
    },

    SAYCE: {
      cisac: '095',
      country: 'EC',
      mandatoryRecords: ['HDR','GRH','NWR','SPU','SWR','PWR','GRT','TRL'],
      fieldConstraints: {
        SWR: [
          { field: 'interestedPartyNum', rule: 'non-blank',
            check: (val) => val.trim().length > 0,
            message: 'SAYCE: writer IPN required' },
        ],
      },
      crossRecord: [],
    },
  };

  // ────────────────────────────────────────────────────────────────────────
  // AUDIT — run a transmission against a society layout
  // ────────────────────────────────────────────────────────────────────────
  function auditTransmission(lines, societyCode, version) {
    const layout = SOCIETY_LAYOUTS[societyCode];
    if (!layout) return { error: 'Unknown society: ' + societyCode };

    const issues = [];
    const checks = [];

    // 1. Mandatory records present
    const presentTypes = new Set(lines.map(l => l.slice(0, 3)));
    layout.mandatoryRecords.forEach(rt => {
      const ok = presentTypes.has(rt);
      checks.push({ kind: 'mandatory', name: 'has ' + rt, pass: ok });
      if (!ok) issues.push({ severity: 'high', record: rt, message: rt + ' record missing (mandatory for ' + societyCode + ')' });
    });

    // 2. Field-level conformance per record
    for (const line of lines) {
      const rt = line.slice(0, 3);
      const fieldSpec = FIELD_SPECS[rt];
      if (!fieldSpec) continue;
      const fields = fieldSpec(version);

      // Generic field-type checks
      for (const f of fields) {
        const val = line.slice(f.start, f.start + f.length);
        if (val.length !== f.length) {
          issues.push({ severity: 'high', record: rt, field: f.name, message: 'Field length mismatch (got ' + val.length + ', expected ' + f.length + ')' });
          continue;
        }
        if (f.type === 'F' && f.valid && !f.valid.includes(val)) {
          // soft check: only fail if value is non-blank and not in list
          if (val.trim().length > 0 && !f.valid.includes(val)) {
            issues.push({ severity: 'medium', record: rt, field: f.name, message: 'Value "' + val + '" not in valid list for ' + f.name });
          }
        }
        if (f.type === 'D' && val.trim() !== '' && !/^\d{8}$/.test(val)) {
          issues.push({ severity: 'high', record: rt, field: f.name, message: 'Date field expects YYYYMMDD, got "' + val + '"' });
        }
        if (f.type === 'T' && val.trim() !== '' && !/^\d{6}$/.test(val)) {
          issues.push({ severity: 'high', record: rt, field: f.name, message: 'Time field expects HHMMSS, got "' + val + '"' });
        }
        if (f.type === 'N' && val.trim() !== '' && !/^\d+\s*$/.test(val) && !/^\s*\d+$/.test(val)) {
          // numeric must be digits (allow padding)
          if (!/^\d+$/.test(val.trim())) {
            issues.push({ severity: 'medium', record: rt, field: f.name, message: 'Numeric field has non-digit content: "' + val + '"' });
          }
        }
      }

      // Society-specific constraints
      const cons = layout.fieldConstraints[rt];
      if (cons) {
        for (const c of cons) {
          const fld = fields.find(f => f.name === c.field);
          if (!fld) continue;
          const val = line.slice(fld.start, fld.start + fld.length);
          const ok = c.check(val);
          checks.push({ kind: 'society-rule', name: societyCode + ': ' + c.message, pass: ok });
          if (!ok) issues.push({ severity: 'high', record: rt, field: c.field, message: c.message });
        }
      }
    }

    // 3. Cross-record society rules
    (layout.crossRecord || []).forEach(c => {
      let ok = false;
      try { ok = !!c.check(lines); } catch (e) { ok = false; }
      checks.push({ kind: 'cross-record', name: societyCode + ': ' + c.name, pass: ok });
      if (!ok) issues.push({ severity: 'high', record: '*', message: c.name });
    });

    return {
      society: societyCode,
      version,
      checksTotal: checks.length,
      checksPass: checks.filter(c => c.pass).length,
      issues,
      ok: issues.length === 0,
    };
  }

  // ────────────────────────────────────────────────────────────────────────
  // Build a representative transmission for byte-diff against a society
  // ────────────────────────────────────────────────────────────────────────
  function buildReferenceTransmission(societyCode, version) {
    if (!window.CwrBuild) return null;

    const ref = {
      ASCAP: { senderId: 199900001, senderName: 'PUBLISHER LLC', publisherIPI: 199900001, writerIPI: 199900002, society: '010' },
      BMI:   { senderId: 199900001, senderName: 'PUBLISHER LLC', publisherIPI: 199900001, writerIPI: 199900003, society: '021' },
      PRS:   { senderId: 199900001, senderName: 'PUBLISHER LLC', publisherIPI: 199900001, writerIPI: 199900004, society: '052' },
      GEMA:  { senderId: 199900001, senderName: 'PUBLISHER GMBH', publisherIPI: 199900001, writerIPI: 199900005, society: '035' },
      SACEM: { senderId: 199900001, senderName: 'PUBLISHER SARL', publisherIPI: 199900001, writerIPI: 199900006, society: '058' },
      JASRAC:{ senderId: 199900001, senderName: 'PUBLISHER KK', publisherIPI: 199900001, writerIPI: 199900007, society: '101' },
      SESAC: { senderId: 199900001, senderName: 'PUBLISHER LLC', publisherIPI: 199900001, writerIPI: 199900008, society: '071' },
      GMR:   { senderId: 199900001, senderName: 'PUBLISHER LLC', publisherIPI: 199900001, writerIPI: 199900009, society: '170' },
      SOCAN: { senderId: 199900001, senderName: 'PUBLISHER INC', publisherIPI: 199900001, writerIPI: 199900010, society: '055' },
      APRA_AMCOS: { senderId: 199900001, senderName: 'PUBLISHER PTY', publisherIPI: 199900001, writerIPI: 199900011, society: '040' },
      STIM:  { senderId: 199900001, senderName: 'PUBLISHER AB', publisherIPI: 199900001, writerIPI: 199900012, society: '079' },
      SIAE:  { senderId: 199900001, senderName: 'PUBLISHER SRL', publisherIPI: 199900001, writerIPI: 199900013, society: '062' },
      AKM:   { senderId: 199900001, senderName: 'PUBLISHER GMBH', publisherIPI: 199900001, writerIPI: 199900014, society: '005' },
      MLC:   { senderId: 199900001, senderName: 'PUBLISHER LLC', publisherIPI: 199900001, writerIPI: 199900015, society: '775' },
      HFA:   { senderId: 199900001, senderName: 'PUBLISHER LLC', publisherIPI: 199900001, writerIPI: 199900016, society: '999' },
      SAYCE: { senderId: 199900001, senderName: 'PUBLISHER SA', publisherIPI: 199900001, writerIPI: 199900017, society: '095' },
    }[societyCode];

    if (!ref) return null;

    // Compute valid IDs so identifier validation passes downstream
    const idv = window.CwrIdValidate;
    const validIswc = idv ? idv.buildValidId('iswc', 123456789) : 'T1234567890';
    const validPubIpi = idv ? idv.buildValidId('ipiName', 199900001) : String(ref.publisherIPI);
    const validWriterIpi = idv ? idv.buildValidId('ipiName', ref.writerIPI - 199000000 + 100) : String(ref.writerIPI);
    const validPerformerIpi = idv ? idv.buildValidId('ipiName', 99099) : '199900099';

    return window.CwrBuild.buildTransmission({
      version,
      senderIpi: validPubIpi,
      senderName: ref.senderName,
      transactionType: 'NWR',
      works: [{
        title: 'TEST WORK FOR ' + societyCode,
        submitterWorkNum: 'TW' + societyCode + '001',
        iswc: validIswc,
        copyrightDate: '20240101',
        languageCode: 'EN',
        publishers: [{
          name: ref.senderName,
          id: 'P' + ref.publisherIPI,
          ipiName: validPubIpi,
          role: 'E',
          publisherType: 'E ',
          controlled: true,
          prShare: 5000, mrShare: 5000, srShare: 5000,
          territories: [{ tisNum: 2136, inclusion: 'I', prShare: 5000, mrShare: 5000, srShare: 5000 }],
        }],
        writers: [{
          id: 'W' + ref.writerIPI,
          ipiName: validWriterIpi,
          lastName: 'SMITH',
          firstName: 'JOHN',
          role: 'CA',
          designation: 'CA',
          controlled: true,
          prShare: 5000, mrShare: 5000, srShare: 5000,
          territories: [{ tisNum: 2136, inclusion: 'I', prShare: 5000, mrShare: 5000, srShare: 5000 }],
          pwrLinks: [{
            publisherIpNum: 'P' + ref.publisherIPI,
            publisherName: ref.senderName,
            writerIpNum: 'W' + ref.writerIPI,
            societyAgreementNum: '',
          }],
        }],
        performers: [{
          lastName: 'BRAND', firstName: 'JANE', ipiName: validPerformerIpi,
          ipiBase: 'I0123456789', performanceLanguage: 'EN',
        }],
      }],
    });
  }

  function auditSociety(societyCode, version) {
    const lines = buildReferenceTransmission(societyCode, version);
    if (!lines) return { error: 'No reference build for ' + societyCode };
    return auditTransmission(lines, societyCode, version);
  }

  function auditAll() {
    const societies = Object.keys(SOCIETY_LAYOUTS);
    const versions = ['2.2', '3.1'];
    const results = [];
    for (const s of societies) {
      for (const v of versions) {
        const r = auditSociety(s, v);
        results.push(r);
      }
    }
    return {
      results,
      summary: {
        total: results.length,
        clean: results.filter(r => r.ok).length,
        totalIssues: results.reduce((s, r) => s + (r.issues || []).length, 0),
      },
    };
  }

  window.CwrByteDiff = {
    SOCIETY_LAYOUTS,
    FIELD_SPECS,
    auditTransmission,
    buildReferenceTransmission,
    auditSociety,
    auditAll,
  };
})();