import { describe, expect, it } from 'vitest'
import {
  createDeterministicLivingSystemPlan,
  createLivingSystemExecutionReceipt,
  createLivingSystemEvent,
  parseLivingSystemPlan,
  validateLivingSystemPlan,
} from './guanghuLivingSystem'

describe('Guanghu living system contract', () => {
  it('binds every event to the persona system, knowledge state, boundaries, and capability registry', () => {
    const event = createLivingSystemEvent({
      currentRoute: 'world',
      eventId: 'event-context',
      intent: 'open-knowledge',
      receiptIds: ['truth-001'],
      requestedRoute: 'world',
      worldOpen: true,
      modelInstanceId: 'model-instance-current',
      knowledgeState: {
        selectedLakeId: 'lake-current',
        mountedSources: ['REPO-012', 'REPO-014'],
      },
    })

    expect(event.personaSystem).toEqual({
      humanAnchorId: 'ICE-GL∞',
      personaSystemId: 'ICE-P-ZY001',
      memoryProtocolRoot: 'REPO-012',
      modelInstanceId: 'model-instance-current',
    })
    expect(event.knowledgeState).toEqual({
      selectedLakeId: 'lake-current',
      mountedSources: ['REPO-012', 'REPO-014'],
    })
    expect(event.permissionBoundary.allowedCapabilities).toContain('knowledge.open')
    expect(event.responsibilityBoundary.controllerPersonaSystemId).toBe('ICE-P-ZY001')
    expect(event.capabilityRegistry).toContainEqual(expect.objectContaining({
      id: 'knowledge.open',
      outputType: 'CapabilityCall',
    }))
  })

  it('drops a claimed runtime binding when its issuing receipt is absent', () => {
    const event = createLivingSystemEvent({
      currentRoute: 'world',
      eventId: 'event-unverified-runtime',
      intent: 'navigate',
      receiptIds: [],
      requestedRoute: 'world',
      worldOpen: true,
      runtimeBinding: {
        bindingId: 'binding-unverified',
        nodeId: 'JD-FD-PRIMARY',
        personaSystemId: 'ICE-P-ZY001',
        modelInstanceId: 'model-unverified',
        issuedByReceiptId: 'missing-receipt',
        status: 'verified',
      },
    })

    expect(event.currentSystemState.runtimeBinding).toBeNull()
    expect(event.personaSystem.modelInstanceId).toBeNull()
  })

  it('accepts a model-native navigation plan with a bounded visual scene', () => {
    const event = createLivingSystemEvent({
      currentRoute: 'world',
      intent: 'navigate',
      requestedRoute: 'fifth-domain',
      worldOpen: true,
      receiptIds: ['receipt-001'],
      now: 1_785_670_000_000,
      eventId: 'event-001',
    })
    const plan = parseLivingSystemPlan(JSON.stringify({
      version: 1,
      eventId: 'event-001',
      intent: 'navigate',
      planId: 'plan-001',
      requiredTruth: ['receipt-001'],
      uiProjection: {
        route: 'fifth-domain',
        stateLabel: 'model-proposed',
        scene: {
          depth: 'immersive',
          motion: 'responsive',
          starDensity: 'rich',
          connectionEmphasis: 'active-route',
        },
      },
      navigationAction: { type: 'navigate', route: 'fifth-domain' },
      capabilityCall: null,
      receiptSchema: { outcome: 'pending-evidence', requiredEvidence: ['ui.route.readback'] },
    }))

    expect(validateLivingSystemPlan(event, plan)).toEqual({
      accepted: true,
      plan,
    })
  })

  it('fails closed when a model plan references truth that was not supplied', () => {
    const event = createLivingSystemEvent({
      currentRoute: 'world',
      intent: 'navigate',
      requestedRoute: 'fifth-domain',
      worldOpen: true,
      receiptIds: [],
      eventId: 'event-002',
      now: 1,
    })
    const plan = parseLivingSystemPlan(JSON.stringify({
      version: 1,
      eventId: 'event-002',
      intent: 'navigate',
      planId: 'plan-002',
      requiredTruth: ['invented-receipt'],
      uiProjection: {
        route: 'fifth-domain',
        stateLabel: 'model-proposed',
        scene: {
          depth: 'focused', motion: 'quiet', starDensity: 'balanced', connectionEmphasis: 'contextual',
        },
      },
      navigationAction: { type: 'navigate', route: 'fifth-domain' },
      capabilityCall: null,
      receiptSchema: { outcome: 'pending-evidence', requiredEvidence: [] },
    }))

    expect(validateLivingSystemPlan(event, plan)).toEqual({
      accepted: false,
      reason: 'unverified_truth',
    })
  })

  it('redirects protected routes to the login gate while the world is closed', () => {
    const event = createLivingSystemEvent({
      currentRoute: 'world',
      intent: 'navigate',
      requestedRoute: 'fifth-domain',
      worldOpen: false,
      receiptIds: [],
      eventId: 'event-003',
      now: 1,
    })

    expect(createDeterministicLivingSystemPlan(event)).toMatchObject({
      uiProjection: {
        route: 'world-login',
        scene: { depth: 'focused', motion: 'responsive' },
      },
      navigationAction: { route: 'world-login' },
    })
  })

  it('rejects a model plan that substitutes a different host action', () => {
    const event = createLivingSystemEvent({
      currentRoute: 'world',
      eventId: 'event-host-action',
      intent: 'open-knowledge',
      requestedRoute: 'world',
      worldOpen: false,
      receiptIds: [],
      now: 1,
    })
    const plan = parseLivingSystemPlan(JSON.stringify({
      version: 1,
      eventId: event.eventId,
      intent: 'open-agent-workspace',
      planId: 'substituted-action',
      requiredTruth: [],
      uiProjection: {
        route: 'world',
        stateLabel: 'model-proposed',
        scene: {
          depth: 'overview',
          motion: 'responsive',
          starDensity: 'balanced',
          connectionEmphasis: 'contextual',
        },
      },
      navigationAction: { type: 'navigate', route: 'world' },
      capabilityCall: {
        type: 'capability',
        capabilityId: 'agent.workspace.open',
        input: {},
      },
      receiptSchema: { outcome: 'pending-evidence', requiredEvidence: [] },
    }))

    expect(validateLivingSystemPlan(event, plan)).toEqual({
      accepted: false,
      reason: 'intent_mismatch',
    })
  })

  it('rejects route substitution, closed-world projection, and capability substitution', () => {
    const openEvent = createLivingSystemEvent({
      currentRoute: 'world',
      eventId: 'event-route-boundary',
      intent: 'navigate',
      requestedRoute: 'fifth-domain',
      worldOpen: true,
      receiptIds: [],
      now: 1,
    })
    const openPlan = createDeterministicLivingSystemPlan(openEvent)
    expect(validateLivingSystemPlan(openEvent, {
      ...openPlan,
      navigationAction: { type: 'navigate', route: 'world' },
    })).toEqual({ accepted: false, reason: 'route_mismatch' })

    const closedEvent = createLivingSystemEvent({
      currentRoute: 'world',
      eventId: 'event-world-boundary',
      intent: 'navigate',
      requestedRoute: 'fifth-domain',
      worldOpen: false,
      receiptIds: [],
      now: 1,
    })
    const closedPlan = createDeterministicLivingSystemPlan(closedEvent)
    const protectedPlan = {
      ...closedPlan,
      uiProjection: { ...closedPlan.uiProjection, route: 'fifth-domain' as const },
      navigationAction: { type: 'navigate' as const, route: 'fifth-domain' as const },
    }
    expect(validateLivingSystemPlan(closedEvent, protectedPlan)).toEqual({
      accepted: false,
      reason: 'world_closed',
    })

    const capabilityEvent = createLivingSystemEvent({
      currentRoute: 'world',
      eventId: 'event-capability-boundary',
      intent: 'open-knowledge',
      requestedRoute: 'world',
      worldOpen: true,
      receiptIds: [],
      now: 1,
    })
    const capabilityPlan = createDeterministicLivingSystemPlan(capabilityEvent)
    expect(validateLivingSystemPlan(capabilityEvent, {
      ...capabilityPlan,
      capabilityCall: {
        type: 'capability',
        capabilityId: 'agent.workspace.open',
        input: {},
      },
    })).toEqual({ accepted: false, reason: 'capability_mismatch' })
  })

  it('rejects chatty or structurally invalid model output', () => {
    expect(parseLivingSystemPlan('我来帮你进入第五域')).toBeNull()
    expect(parseLivingSystemPlan('{"route":"fifth-domain"}')).toBeNull()
    expect(parseLivingSystemPlan(JSON.stringify({
      version: 1,
      eventId: 'event-001',
      intent: 'navigate',
      planId: 'legacy-theme-adapter',
      route: 'fifth-domain',
      requiredTruth: [],
      scene: {
        depth: 'immersive', motion: 'active', starDensity: 'rich', connectionEmphasis: 'network',
      },
    }))).toBeNull()
  })

  it('binds a local executor receipt to the accepted event and plan', () => {
    const plan = createDeterministicLivingSystemPlan(createLivingSystemEvent({
      currentRoute: 'world',
      intent: 'navigate',
      requestedRoute: 'zero-core',
      worldOpen: true,
      receiptIds: [],
      eventId: 'event-004',
      now: 1,
    }))

    expect(createLivingSystemExecutionReceipt({
      plan,
      source: 'fallback',
      outcome: 'executed',
      evidence: ['ui.route:zero-core'],
      now: 2,
    })).toEqual({
      version: 1,
      receiptId: 'local-execution:fallback-event-004:executed',
      eventId: 'event-004',
      intent: 'navigate',
      planId: 'fallback-event-004',
      route: 'zero-core',
      source: 'fallback',
      outcome: 'executed',
      evidence: ['ui.route:zero-core'],
      completedAt: 2,
    })
  })

  it('refuses to create a successful receipt before real evidence exists', () => {
    const plan = createDeterministicLivingSystemPlan(createLivingSystemEvent({
      currentRoute: 'world',
      intent: 'navigate',
      requestedRoute: 'zero-core',
      worldOpen: true,
      receiptIds: [],
      eventId: 'event-no-evidence',
      now: 1,
    }))

    expect(() => createLivingSystemExecutionReceipt({
      plan,
      source: 'fallback',
      outcome: 'executed',
      evidence: [],
      now: 2,
    })).toThrow('guanghu_living_system_success_evidence_required')
  })
})