import { createServer } from 'vite';

const storage = new Map();
globalThis.window = {
  localStorage: {
    getItem(key) {
      return storage.has(key) ? storage.get(key) : null;
    },
    setItem(key, value) {
      storage.set(key, String(value));
    },
    removeItem(key) {
      storage.delete(key);
    },
    clear() {
      storage.clear();
    }
  }
};

const server = await createServer({
  logLevel: 'error',
  server: { middlewareMode: true },
  appType: 'custom'
});

try {
  const { campaignStorageKey, loadCampaignState } = await server.ssrLoadModule('/src/game/state/campaignState.ts');

  storage.clear();
  const empty = loadCampaignState();
  assert(empty.version === 1 && empty.step === 'new', `Expected empty storage to create initial campaign state: ${JSON.stringify(empty)}`);

  storage.clear();
  storage.set(
    campaignStorageKey,
    JSON.stringify({
      updatedAt: '2026-07-01T00:00:00.000Z',
      step: 'first-camp',
      activeSaveSlot: 1,
      gold: 180,
      inventory: { bean: 2 },
      completedCampDialogues: ['bond-a', 'bond-a'],
      completedCampVisits: ['visit-a', 'visit-a']
    })
  );
  const legacy = loadCampaignState();
  assert(legacy.version === 1, `Expected legacy save without version to normalize to v1: ${JSON.stringify(legacy)}`);
  assert(legacy.step === 'first-camp' && legacy.gold === 180, `Expected legacy save progress to survive: ${JSON.stringify(legacy)}`);
  assert(Array.isArray(legacy.roster) && Array.isArray(legacy.bonds), `Expected legacy save arrays to be restored: ${JSON.stringify(legacy)}`);
  assert(
    legacy.completedCampDialogues.length === 1 && legacy.completedCampVisits.length === 1,
    `Expected legacy save duplicate completion flags to be deduped: ${JSON.stringify(legacy)}`
  );
  assert(
    Array.isArray(legacy.selectedSortieUnitIds) &&
      typeof legacy.sortieFormationAssignments === 'object' &&
      typeof legacy.sortieItemAssignments === 'object',
    `Expected modern sortie fields to be restored: ${JSON.stringify(legacy)}`
  );

  storage.clear();
  storage.set(
    campaignStorageKey,
    JSON.stringify({
      version: 1,
      updatedAt: '',
      step: 'third-camp',
      activeSaveSlot: '2',
      gold: '410',
      roster: { corrupted: true },
      bonds: { corrupted: true },
      completedCampDialogues: ['dialogue-a', 17, 'dialogue-a', ''],
      completedCampVisits: 'visit-a',
      inventory: { bean: '3', wine: -2, empty: 0 },
      selectedSortieUnitIds: { corrupted: true },
      sortieFormationAssignments: 'front',
      sortieItemAssignments: {
        'liu-bei': { bean: '2', wine: -1 },
        'guan-yu': 'broken'
      },
      battleHistory: []
    })
  );
  const malformed = loadCampaignState();
  assert(malformed.step === 'third-camp', `Expected malformed save progress to survive: ${JSON.stringify(malformed)}`);
  assert(malformed.activeSaveSlot === 2 && malformed.gold === 410, `Expected malformed numeric fields to normalize: ${JSON.stringify(malformed)}`);
  assert(Array.isArray(malformed.roster) && malformed.roster.length === 0, `Expected malformed roster to reset to an array: ${JSON.stringify(malformed)}`);
  assert(Array.isArray(malformed.bonds) && malformed.bonds.length === 0, `Expected malformed bonds to reset to an array: ${JSON.stringify(malformed)}`);
  assert(
    malformed.completedCampDialogues.length === 1 &&
      malformed.completedCampDialogues[0] === 'dialogue-a' &&
      malformed.completedCampVisits.length === 0,
    `Expected malformed completion lists to keep unique strings only: ${JSON.stringify(malformed)}`
  );
  assert(
    malformed.inventory.bean === 3 &&
      malformed.inventory.wine === undefined &&
      malformed.sortieItemAssignments['liu-bei']?.bean === 2 &&
      malformed.sortieItemAssignments['liu-bei']?.wine === undefined &&
      Object.keys(malformed.sortieFormationAssignments).length === 0,
    `Expected malformed inventory and sortie assignments to normalize: ${JSON.stringify(malformed)}`
  );

  storage.clear();
  storage.set(
    campaignStorageKey,
    JSON.stringify({
      version: 1,
      updatedAt: '2026-07-03T00:00:00.000Z',
      step: 'lost-between-battles',
      activeSaveSlot: 1,
      gold: 90
    })
  );
  const invalidStep = loadCampaignState();
  assert(invalidStep.step === 'new', `Expected unknown campaign step to reset safely: ${JSON.stringify(invalidStep)}`);
  assert(invalidStep.gold === 90, `Expected unknown-step save to keep harmless economy data: ${JSON.stringify(invalidStep)}`);

  storage.clear();
  storage.set(campaignStorageKey, JSON.stringify({ version: 99, step: 'sixty-sixth-camp' }));
  const unsupported = loadCampaignState();
  assert(unsupported.step === 'new', `Expected unsupported future save version to be ignored: ${JSON.stringify(unsupported)}`);

  storage.clear();
  storage.set(campaignStorageKey, JSON.stringify({ version: 99, step: 'sixty-sixth-camp' }));
  storage.set(
    `${campaignStorageKey}:slot-2`,
    JSON.stringify({
      version: 1,
      updatedAt: '2026-07-02T00:00:00.000Z',
      step: 'second-camp',
      activeSaveSlot: 2,
      gold: 260
    })
  );
  const fallback = loadCampaignState();
  assert(fallback.step === 'second-camp' && fallback.activeSaveSlot === 2, `Expected valid slotted save fallback: ${JSON.stringify(fallback)}`);

  console.log('Verified campaign save normalization, malformed-field recovery, unknown-step recovery, unsupported-version rejection, and slotted fallback.');
} finally {
  await server.close();
}

function assert(condition, message) {
  if (!condition) {
    throw new Error(message);
  }
}