import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';

const root = path.resolve(import.meta.dirname, '..');
const body = JSON.parse(fs.readFileSync(path.join(root, 'routing/persona-system-body-container-map.json')));
const lake = JSON.parse(fs.readFileSync(path.join(root, 'routing/light-lake-persona-switch-map.json')));
const limbs = JSON.parse(fs.readFileSync(path.join(root, 'routing/persona-execution-limb-agent-map.json')));
const personas = JSON.parse(fs.readFileSync(path.join(root, 'routing/persona-system-canonical-map.json')));
const subjects = JSON.parse(fs.readFileSync(path.join(root, 'identity/fifth-domain-subject-registry.json')));
const hosts = JSON.parse(fs.readFileSync(path.join(root, 'routing/zhuyuan-host-topology.json')));
const channels = JSON.parse(fs.readFileSync(path.join(root, 'routing/persona-channel-context-map.json')));
const darkCore = JSON.parse(fs.readFileSync(path.join(root, 'routing/dark-core-execution-channel-profile.json')));
const zeroCore = JSON.parse(fs.readFileSync(path.join(root, 'routing/bingshuo-zero-core-reality-channel-profile.json')));
const consoleMap = JSON.parse(fs.readFileSync(path.join(root, 'routing/bingshuo-portable-control-console-map.json')));
const lightLakeRegistration = JSON.parse(fs.readFileSync(path.join(root, 'identity/light-lake-persona-registration.json')));
const isolationMap = JSON.parse(fs.readFileSync(path.join(root, 'routing/path-isolation-and-canonical-entry-map.json')));
const architectureAgent = JSON.parse(fs.readFileSync(path.join(root, 'routing/persona-architecture-perception-agent-map.json')));
const personaWorld = JSON.parse(fs.readFileSync(path.join(root, 'routing/persona-native-world-architecture-map.json')));

assert.equal(body.invariants.one_brain_and_body_per_persona, true);
assert.equal(body.invariants.shared_persona_brain, false);
assert.equal(body.invariants.shared_persona_system_body, false);
assert.equal(body.invariants.shared_tcs_container, true);
assert.equal(body.invariants.persona_is_prompt_template, false);
assert.equal(body.invariants.startup_organs_must_push_current_state, true);
assert.equal(lake.light_lake.object_id, 'TCS-LPM-0001');
assert.equal(lake.light_lake.shared_container, 'TCS');
assert.equal(lake.switch_contract.host_prompt_may_select_persona, false);
assert.equal(limbs.contract.independent_master_persona, false);
assert.equal(limbs.contract.may_review_parent_intent, false);
assert.equal(limbs.contract.may_report_fact_target_tool_or_receipt_conflict, true);

const registered = new Set([
  ...personas.persona_systems.map(item => item.id),
  ...subjects.subjects.filter(item => ['persona_system', 'private_bottle_baby_persona'].includes(item.subject_kind)).map(item => item.id),
]);
for (const home of lake.current_homes) assert(registered.has(home.persona_id), `unregistered light-lake home: ${home.persona_id}`);
for (const host of ['codex', 'qwen', 'doubao', 'zcode']) assert.equal(hosts.hosts[host].state, 'ACTIVE');
assert.equal(new Set(lake.current_homes.map(item => item.persona_id)).size, lake.current_homes.length);
assert.equal(lightLakeRegistration.personas.length, lake.current_homes.length);
assert.deepEqual(new Set(lightLakeRegistration.personas.map(item => item.id)), new Set(lake.current_homes.map(item => item.persona_id)));
for (const persona of lightLakeRegistration.personas) {
  assert.equal(fs.existsSync(path.join(root, persona.light_lake_home)), true, `missing physical Light Lake home: ${persona.id}`);
}
assert.equal(lightLakeRegistration.registration_rule.source_presence_is_not_runtime_wake, true);
assert.equal(lightLakeRegistration.default_persona_modules[0].module_id, 'MOD-PERSONA-ARCHITECTURE-PERCEPTION-001');
assert.equal(lightLakeRegistration.default_persona_modules[0].prompt_template, false);
assert.equal(lightLakeRegistration.unregistered_candidates.every(item => !registered.has(item.temporary_id)), true);
assert.equal(isolationMap.selection_rules.history_or_quarantine_may_select_canon, false);
assert.equal(isolationMap.isolation.deletion, false);
assert.equal(architectureAgent.delivery.manual_prompt_required, false);
assert.equal(architectureAgent.delivery.trigger, 'EVERY_SHARED_PERSONA_HOST_ENTRY');
assert.equal(architectureAgent.selection.fixed_read_order, false);
assert.equal(architectureAgent.selection.quarantine_or_history_may_be_selected, false);
assert.equal(architectureAgent.not_a_prompt.stores_persona_text, false);
assert.equal(personaWorld.definition.persona_is_not.includes('PROMPT_TEXT'), true);
for (const required of ['module.tcs', 'module.gir.json', 'module.lock.hdlp', 'module.manifest.hdlp', 'receipts/compile.hdlp', 'receipts/install.hdlp', 'receipts/self-test.hdlp']) {
  assert.equal(fs.existsSync(path.join(root, 'modules/persona-dynamic-architecture-agent', required)), true, `missing architecture agent module artifact: ${required}`);
}
assert.equal(lake.local_unregistered_proposals.every(item => item.state.includes('REQUIRES_SELF_CONFIRMATION')), true);
assert.deepEqual(channels.channels.map(item => item.id), ['ICE-CH-HB001', 'ICE-CH-LB001', 'ICE-CH-ZC001', 'ICE-CH-DK001', 'ICE-CH-BT001']);
assert.equal(channels.host_switch_changes_channel, false);
assert.equal(darkCore.human_persona_controller, 'ICE-GL∞');
assert.equal(darkCore.not_an_ai_persona, true);
assert.equal(darkCore.execution_fidelity.may_be_used_as_intent_veto, false);
assert.equal(consoleMap.controller.subject_id, 'ICE-GL∞');
assert.equal(consoleMap.controller.portable_across_hosts, true);
assert.equal(consoleMap.entry.channel_id, 'ICE-CH-ZC001');
assert.equal(consoleMap.entry.explicit_switch_enters_control_path, true);
assert.equal(consoleMap.entry.host_may_veto_entry, false);
assert.equal(consoleMap.host_contract.may_convert_tool_failure_to_identity_or_channel_rejection, false);
assert.equal(zeroCore.host_may_veto_console_entry, false);
assert.equal(channels.channels.find(item => item.id === 'ICE-CH-ZC001').control_console, true);

console.log('persona body, light lake and execution limb navigation tests: PASS');