import { createHash } from 'node:crypto'
import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
import { dirname, resolve } from 'node:path'
import { fileURLToPath } from 'node:url'

const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
const paths = {
  identity: resolve(root, 'contracts/zero-core-numbering-kernel.json'),
  webview: resolve(root, 'contracts/numbered-ipc-registry.json'),
  broker: resolve(root, 'contracts/direct-local-broker-numbered-registry.json'),
  gls: resolve(root, 'contracts/gls-runtime-registry.json'),
  output: resolve(root, 'generated/unified-number-coordinate-tree.json'),
}

function readSource(path) {
  const bytes = readFileSync(path)
  return {
    value: JSON.parse(bytes.toString('utf8')),
    sha256: createHash('sha256').update(bytes).digest('hex'),
  }
}

export function compileUnifiedNumberTree() {
  const identity = readSource(paths.identity)
  const webview = readSource(paths.webview)
  const broker = readSource(paths.broker)
  const gls = readSource(paths.gls)
  const routes = [
    ...webview.value.operations.map((route) => ({
      transport: 'TAURI_WEBVIEW_NUMBERED_IPC',
      protocolVersion: webview.value.runtime.protocol_version,
      callerNumber: webview.value.runtime.caller_number,
      channelNumber: route.channel_number,
      moduleNumber: route.module_number,
      operationNumber: route.operation_number,
      targetNumber: route.target_number,
      alias: route.alias,
      admission: route.admission,
      effect: route.effect,
      evidence: 'HASH_CHAINED_NUMBERED_IPC_RECEIPT',
      path: `HLP-NUMBER-WORLD-ROOT-001/TAURI/${route.channel_number}/${route.module_number}/${route.operation_number}/${route.target_number}`,
    })),
    ...broker.value.operations.map((route) => ({
      transport: 'DIRECT_LOCAL_NUMBERED_BROKER',
      protocolVersion: broker.value.runtime.protocol_version,
      callerNumber: broker.value.runtime.caller_number,
      channelNumber: route.channel_number,
      moduleNumber: route.module_number,
      operationNumber: route.operation_number,
      targetNumber: route.target_number,
      alias: route.alias,
      admission: ['DISCOVER_NEARBY', 'PING', 'GET_BEIJING_TIME'].includes(route.alias)
        ? 'PREAUTH_LOCAL_SYSTEM_ROUTE'
        : ['OPEN_VISITOR_SESSION', 'RECEIVE_LANGUAGE'].includes(route.alias)
          ? 'BOUNDED_VISITOR_ROUTE'
          : 'AUTHENTICATED_LOCAL_SESSION_WITH_PERSONA_LICENSE_IF_PERSONA_MODE',
      effect: ['DISCOVER_NEARBY', 'PING', 'GET_BEIJING_TIME', 'GET_PERSONA_CARRIER_LICENSE_STATUS', 'GET_WORK_ENVIRONMENT', 'RESOLVE_CAPABILITY_ROUTE', 'INSPECT_MOUNTED_PNCC_REPOSITORY', 'READ_MOUNTED_PNCC_REMOTE_OBJECT', 'QUERY_PNCC_RECEIPT_PROJECTION', 'INSPECT_DEVELOPMENT_WRITE_LANE'].includes(route.alias)
        ? 'READ_OR_STATUS'
        : 'STATE_CHANGE',
      evidence: 'NUMBERED_RESPONSE_PLUS_SESSION_OR_DOMAIN_RECEIPT',
      path: `HLP-NUMBER-WORLD-ROOT-001/BROKER/${route.channel_number}/${route.module_number}/${route.operation_number}/${route.target_number}`,
    })),
  ].sort((left, right) => left.path.localeCompare(right.path, 'en'))
  const uniquePaths = new Set(routes.map((route) => route.path))
  const uniqueOperations = new Set(routes.map((route) => `${route.transport}:${route.operationNumber}`))
  if (routes.length !== uniquePaths.size || routes.length !== uniqueOperations.size) {
    throw new Error('HOLOLAKE_UNIFIED_NUMBER_TREE_DUPLICATE_COORDINATE')
  }
  const identityNodes = identity.value.namespaces.map((namespace) => ({
    nodeKind: 'IDENTITY_NAMESPACE',
    nodeNumber: `HLP-IDENTITY-NS-${namespace.id}`,
    namespaceId: namespace.id,
    subjectKind: namespace.subject_kind,
    domainScope: namespace.domain_scope,
    admission: namespace.human_entry ? 'REGISTERED_HUMAN_NAMESPACE' : 'NON_HUMAN_NAMESPACE',
    executionState: 'AUTHORITY_RESOLUTION_ONLY',
    evidence: identity.value.authority.map_id,
    path: `HLP-NUMBER-WORLD-ROOT-001/IDENTITY/${namespace.id}`,
  })).sort((left, right) => left.path.localeCompare(right.path, 'en'))
  const protocolNodes = [
    ...gls.value.protocols.map((protocol) => ({
      nodeKind: 'GLS_PROTOCOL_SOURCE',
      nodeNumber: protocol.id,
      protocolId: protocol.id,
      title: protocol.title,
      sourceState: protocol.source_format,
      executionState: protocol.projection_state,
      evidence: protocol.source_sha256,
      path: `HLP-NUMBER-WORLD-ROOT-001/GLS/SOURCE/${protocol.id}`,
    })),
    ...gls.value.numbered_reference_nodes.map((reference) => ({
      nodeKind: 'GLS_REFERENCE_ONLY',
      nodeNumber: reference.node_number,
      protocolId: reference.protocol_id,
      title: reference.title,
      sourceState: reference.source_state,
      executionState: reference.execution_state,
      evidence: reference.evidence_paths[0],
      path: `HLP-NUMBER-WORLD-ROOT-001/GLS/REFERENCE/${reference.node_number}`,
    })),
  ].sort((left, right) => left.path.localeCompare(right.path, 'en'))
  const allPaths = [...routes.map((route) => route.path), ...identityNodes.map((node) => node.path), ...protocolNodes.map((node) => node.path)]
  if (new Set(allPaths).size !== allPaths.length
    || gls.value.reconciliation.unresolved_number_reference_count !== 0
    || gls.value.reconciliation.every_dependency_has_number_coordinate !== true
    || protocolNodes.some((node) => node.nodeKind === 'GLS_REFERENCE_ONLY' && node.executionState !== 'REFERENCE_ONLY_NOT_EXECUTABLE')) {
    throw new Error('HOLOLAKE_UNIFIED_NUMBER_TREE_INCOMPLETE_COVERAGE')
  }
  return {
    schema: 'hololake.unified-number-coordinate-tree/v2',
    recordId: 'HLP-UNIFIED-NUMBER-TREE-001',
    state: 'MACHINE_COMPILED_STARTUP_ENFORCED',
    rootNumber: 'HLP-NUMBER-WORLD-ROOT-001',
    identityAuthority: {
      mapId: identity.value.authority.map_id,
      mapVersion: identity.value.authority.map_version,
      namespaces: identity.value.namespaces.map((namespace) => ({
        namespaceId: namespace.id,
        roots: namespace.roots,
        prefixes: namespace.prefixes,
        subjectKind: namespace.subject_kind,
        domainScope: namespace.domain_scope,
      })),
    },
    sources: [
      { recordId: identity.value.record_id, sha256: identity.sha256 },
      { recordId: webview.value.record_id, sha256: webview.sha256 },
      { recordId: broker.value.record_id, sha256: broker.sha256 },
      { recordId: gls.value.record_id, sha256: gls.sha256 },
    ],
    invariants: {
      numberIsStableCoordinateNotAuthority: true,
      pathIsUniqueNavigation: true,
      admissionIsSeparateFromIdentity: true,
      everyPhysicalCallHasNumberedRoute: true,
      everyAcceptedCallHasEvidenceClass: true,
      everyProtocolReferenceHasNumberCoordinate: true,
      referenceOnlyNodesNeverExecutable: true,
      unresolvedNumberReferenceCount: 0,
      mismatchedCoordinate: 'FAIL_CLOSED',
    },
    coordinateCount: routes.length + identityNodes.length + protocolNodes.length,
    routeCount: routes.length,
    identityNodeCount: identityNodes.length,
    protocolNodeCount: protocolNodes.length,
    referenceOnlyNodeCount: protocolNodes.filter((node) => node.nodeKind === 'GLS_REFERENCE_ONLY').length,
    identityNodes,
    protocolNodes,
    routes,
  }
}

const compiled = compileUnifiedNumberTree()
const output = `${JSON.stringify(compiled, null, 2)}\n`
if (process.argv.includes('--check')) {
  if (readFileSync(paths.output, 'utf8') !== output) {
    throw new Error('HOLOLAKE_UNIFIED_NUMBER_TREE_STALE')
  }
} else {
  mkdirSync(dirname(paths.output), { recursive: true })
  writeFileSync(paths.output, output)
}