/**
 * DI 装配 —— `app/` 是**唯一组装层**(编码规范 §5.2)。
 * 只有这里能同时认识多个模块:new 出 adapter、注入 port、把用例接起来。
 *
 * 跨层协作一律经端口注入:`ledger` 要发数据事件 → 注入 `event` 的出口;
 * `event` 的三级消费下游(trigger L7 / message L2)在其**上**,同样经端口注入。
 */
import { Pool } from 'pg';
import { drizzle } from 'drizzle-orm/node-postgres';
import { evaluateCondition } from '@sfeel';
import type { Db } from '@shared/db.ts';

import type { EventService, TriggerMatcher } from '@modules/event';
import { createEventService, createEventStore } from '@modules/event';
import type { LedgerService } from '@modules/ledger';
import { createDraftStore, createLedgerService, createLedgerStore, DRAFT_DDL } from '@modules/ledger';
import type { OrgService, InFlightWorkProbe } from '@modules/org';
import {
  createGrantRepository,
  createOrgService,
  createPositionRepository,
  createSessionRepository,
  createStaffRepository,
  createWorkGroupRepository,
  hashPassword,
  newSessionToken,
  verifyPassword,
} from '@modules/org';
import type { LlmService, ModelGateway } from '@modules/llm';
import {
  createLlmInstanceRepository,
  createLlmService,
  createModelGateway,
  createProviderInvoker,
  createReplayStore,
} from '@modules/llm';
import type { MemoryService } from '@modules/memory';
import { createActivityMemoryStore, createMemoryService, createTaskMemoryStore } from '@modules/memory';
import type { ToolboxService, ToolHandler, ToolInvoker } from '@modules/toolbox';
import {
  createSchemaValidator,
  createToolInvoker,
  createToolRegistry,
  createToolReplayStore,
  createToolRuntime,
  createToolboxService,
} from '@modules/toolbox';
import type { MessageService } from '@modules/message';
import { createMessageRepository, createMessageService } from '@modules/message';
import type { HumanToolService } from '@modules/human-tool';
import { createCardStore, createHumanToolService } from '@modules/human-tool';
import type { InteractionService } from '@modules/interaction';
import { createInteractionService, createInteractionStore, templateIsSafe } from '@modules/interaction';
import type { ActivityRegistryService } from '@modules/activity-registry';
import { createSkillEngineService } from '@modules/skill-engine';
import { createRegistryService, createRegistryStore } from '@modules/activity-registry';
import type { ReleaseService } from '@modules/release';
import { createIntentStore, createReleaseService } from '@modules/release';
import type { TaskService } from '@modules/task';
import type { ProcessService } from '@modules/process';
import type { TriggerService } from '@modules/trigger';
import type { MinuteService } from '@modules/minute';
import type { ReportService } from '@modules/report';
import { FIRST_PARTY_TOOLS } from './tools/first-party.ts';
import { wireEngines } from './wiring/engines.ts';
import { wireDeskElements } from './wiring/desk-elements.ts';
import type { ChannelService } from '@modules/channel';
import {
  createChannelRepository,
  createChannelService,
  createFileAttachmentArchive,
  createSimulatedMailTransport,
} from '@modules/channel';

import type { AppConfig } from './config.ts';
import { createIdGenerator, systemClock } from './runtime.ts';
import { createSecretBox, loadSecretKey } from './secret-box.ts';
import { createBroadcaster } from './broadcast.ts';
import type { Broadcaster } from './broadcast.ts';

export type Container = {
  readonly config: AppConfig;
  /** 投递回执广播 —— 前端 SSE 的服务端一侧;不承担投递语义 */
  readonly broadcaster: Broadcaster;
  readonly pool: Pool;
  readonly db: Db;
  readonly org: OrgService;
  readonly ledger: LedgerService;
  readonly event: EventService;
  readonly llm: LlmService;
  readonly modelGateway: ModelGateway;
  readonly memory: MemoryService;
  readonly toolbox: ToolboxService;
  readonly toolInvoker: ToolInvoker;
  readonly message: MessageService;
  readonly channel: ChannelService;
  readonly humanTool: HumanToolService;
  readonly interaction: InteractionService;
  readonly registry: ActivityRegistryService;
  readonly release: ReleaseService;
  readonly task: TaskService;
  readonly process: ProcessService;
  readonly trigger: TriggerService;
  readonly minute: MinuteService;
  readonly report: ReportService;
  close(): Promise<void>;
};

/**
 * 在途工作探针 —— 停用前置检查要问的是 task(L6)与 human-tool(L3),二者层级在 org 之上,
 * 故以**延迟绑定**的端口接入:org 先构造,真身就位后回填(§5.2 跨层协作经端口)。
 */
function createDeferredInFlightProbe(): InFlightWorkProbe & { bind(real: InFlightWorkProbe): void } {
  let real: InFlightWorkProbe | undefined;
  return {
    openTasksOf: async (id) => (real === undefined ? [] : real.openTasksOf(id)),
    openCardsOf: async (id) => (real === undefined ? [] : real.openCardsOf(id)),
    openApprovalsOf: async (id) => (real === undefined ? [] : real.openApprovalsOf(id)),
    bind(next) {
      real = next;
    },
  };
}

/**
 * 触发器判定的**延迟绑定**:`event`(L1)在 `trigger`(L7)之前构造,
 * 用一层可后填的间接层把环解开 —— 端口不变,装配顺序解耦(§5.2)。
 */
function createDeferredTriggerMatcher(): TriggerMatcher & { bind(real: TriggerMatcher): void } {
  let real: TriggerMatcher | undefined;
  return {
    match: async (envelope) => (real === undefined ? [] : real.match(envelope)),
    bind(next) {
      real = next;
    },
  };
}

/**
 * 监听内容条件的求值 —— @sfeel 的求值语义**前后端同源**(§8.3)。
 * 表达式写坏了不该让事件流停摆:求值异常按「不命中」处置并留痕。
 */
const sfeelEvaluator = (expression: string, scope: Readonly<Record<string, unknown>>): boolean => {
  try {
    return evaluateCondition(expression, scope);
  } catch (error) {
    process.stderr.write(
      `[listener] 条件求值失败,按不命中处置:${expression} —— ${error instanceof Error ? error.message : String(error)}\n`,
    );
    return false;
  }
};

/** 第一方工具实现 —— 由 app 注册进 ToolRuntime;活动只见调用契约 */
export const firstPartyToolHandlers = new Map<string, ToolHandler>(FIRST_PARTY_TOOLS);

export async function createContainer(config: AppConfig): Promise<Container> {
  const pool = new Pool({ connectionString: config.databaseUrl, max: 10 });
  /*
   * 空闲连接被服务端掐断(重启、`pg_terminate_backend`、网络抖动)会以 'error' 事件抛到池上;
   * **没有处理器就是未捕获异常,整个进程随之退出** —— 一次运维操作能把 API 带崩。
   * 池会自行剔除坏连接并在下次取用时重连,这里只负责让它别掀桌子。
   */
  pool.on('error', (error: Error) => {
    process.stderr.write(`[pg] 空闲连接异常(已剔除,下次取用自动重连):${error.message}\n`);
  });
  const db = drizzle(pool);
  const ids = createIdGenerator();
  const secrets = createSecretBox(loadSecretKey());

  // 草稿层的建表:ledger schema 的唯一写者是 ledger adapter,DDL 在其出口给出
  await pool.query(DRAFT_DDL);

  const inFlightProbe = createDeferredInFlightProbe();

  const org = createOrgService({
    positions: createPositionRepository(db),
    staff: createStaffRepository(db),
    grants: createGrantRepository(db),
    sessions: createSessionRepository(db),
    workGroups: createWorkGroupRepository(db),
    // 散列算法在 adapter,usecase 只认这三个动作(ADR-010)
    passwords: { hash: hashPassword, verify: verifyPassword, newToken: newSessionToken },
    inFlight: inFlightProbe,
    clock: systemClock,
    seedPassword: config.seedPassword,
    ids,
  });

  // message 是 event 的 `MessageFallback` 实现面 —— event(L1)不反向依赖它,由此处注入
  const message = createMessageService({
    repo: createMessageRepository(db),
    org: {
      staffOfPosition: async (positionId) => {
        const { staff } = await org.listStaff();
        return staff.filter((s) => s.positionId === positionId).map((s) => ({ id: s.id }));
      },
      governanceStaff: async () => {
        const { staff } = await org.listStaff();
        const governing = await Promise.all(
          staff.map(async (s) => ({
            s,
            ok: await org.authorize(s.id, { kind: 'governance', function: 'task' }, 'govern'),
          })),
        );
        return governing.filter((g) => g.ok).map((g) => ({ id: g.s.id }));
      },
    },
    clock: systemClock,
    ids,
  });

  const triggerMatcher = createDeferredTriggerMatcher();

  const event = createEventService({
    store: createEventStore(db, ids),
    clock: systemClock,
    ids,
    evaluate: sfeelEvaluator,
    triggers: triggerMatcher,
    messages: message,
  });

  const ledger = createLedgerService({
    store: createLedgerStore(pool),
    drafts: createDraftStore(pool),
    events: { publish: async (envelope) => void (await event.publish(envelope)) },
    clock: systemClock,
    ids,
  });

  const instances = createLlmInstanceRepository(db);
  const provider = createProviderInvoker();
  const llm = createLlmService({ instances, provider, secrets, clock: systemClock, ids });
  const modelGateway = createModelGateway({
    instances,
    provider,
    replay: createReplayStore(db),
    secrets,
    clock: systemClock,
    mode: 'live',
  });

  const memory = createMemoryService({
    tasks: createTaskMemoryStore(db),
    activities: createActivityMemoryStore(db),
    model: {
      // 系统用途模型:叙述性小结 / 汇报生成 / 蒸馏钩子 —— 计量入系统账,不占活动预算
      generate: async (input) => {
        const result = await modelGateway.generate({
          model: input.model,
          prompt: input.prompt,
          ...(input.outputSchema === undefined ? {} : { outputSchema: input.outputSchema }),
          label: 'system-use',
        });
        return { text: result.text, ...(result.object === undefined ? {} : { object: result.object }) };
      },
      systemModelName: async () => (await llm.systemUseBinding())?.name,
    },
    clock: systemClock,
    ids,
  });

  const toolRegistry = createToolRegistry(db);
  const toolRuntime = createToolRuntime(firstPartyToolHandlers);
  const schemas = createSchemaValidator();
  const toolbox = createToolboxService({
    registry: toolRegistry,
    runtime: toolRuntime,
    schemas,
    secrets,
    clock: systemClock,
  });
  const toolInvoker = createToolInvoker({
    registry: toolRegistry,
    runtime: toolRuntime,
    replay: createToolReplayStore(db),
    schemas,
    secrets,
    clock: systemClock,
    mode: 'live',
  });

  const channel = createChannelService({
    channels: createChannelRepository(db),
    events: {
      ingestInbound: (input) => event.ingestInbound(input),
      recordOutbound: (ref) => event.recordOutbound(ref),
    },
    ledger: { systemWrite: (input) => ledger.systemWrite(input) },
    mail: createSimulatedMailTransport(db, ids),
    archive: createFileAttachmentArchive(config.attachmentRoot),
    clock: systemClock,
    ids,
  });

  /* ── L3/L4:交互、人类工具、活动库、放行门 ─────────────────────── */

  const interaction = createInteractionService({
    store: createInteractionStore(db),
    events: {
      publishHumanEvent: async (input) => {
        await event.publish({
          type: 'human',
          correlation: {
            target: { kind: 'task', id: input.taskId },
            cause: { kind: 'card-reply', ref: input.cardId },
            keys: { cardId: input.cardId },
          },
          payload: { data: input.payload },
          occurredAt: systemClock.now().toISOString(),
          source: { kind: 'desk' },
        });
      },
    },
    memory: {
      append: async (input) =>
        void (await memory.append({
          ...input,
          stamp: { contractVersion: '1', businessModelVersion: '1', skillVersions: [] },
        })),
      // 对话流的 AI 发言与系统事件由此投影而来 —— 与工作日志同源
      history: (taskId) => memory.history(taskId),
    },
    audience: { canSee: async () => true },
    clock: systemClock,
    ids,
  });

  const humanTool = createHumanToolService({
    cards: createCardStore(db),
    outbox: { sendElicitation: (input) => message.sendElicitation(input) },
    memory: {
      append: async (input) =>
        void (await memory.append({
          ...input,
          stamp: { contractVersion: '1', businessModelVersion: '1', skillVersions: [] },
        })),
    },
    events: {
      publishHumanEvent: async (input) => {
        await event.publish({
          type: 'human',
          correlation: {
            target: { kind: 'task', id: input.taskId },
            cause: { kind: 'card-reply', ref: input.cardId },
            keys: { cardId: input.cardId },
          },
          payload: { data: input.payload },
          occurredAt: systemClock.now().toISOString(),
          source: { kind: 'desk' },
        });
      },
    },
    clock: systemClock,
    ids,
  });

  const registry = createRegistryService({
    store: createRegistryStore(db),
    tools: { assertContractsAvailable: (names) => toolbox.assertContractsAvailable(names) },
    models: { assertNamesBound: (names) => llm.assertNamesBound(names) },
    ledger: {
      applyDeclarations: async (declarations) => {
        // 安装时依声明**自生长**:声明合并 → DDL → 只增不破坏
        const results = await ledger.applyDeclarations(declarations);
        return results.map((r) => ({
          applied: r.applied,
          conflicts: r.conflicts.map((c) => ({ field: c.field, message: c.message })),
        }));
      },
    },
    templates: { isSafe: templateIsSafe },
    clock: systemClock,
    ids,
    // 首次安装无历史 → 免回放审(OS 11.2)
    replayCases: async () => [],
    sdkVersion: '0.1.0-m5',
  });

  /*
   * skill-engine(L4)—— 技能是活动内部的构件格式,由两个范式引擎装配。
   * 目录与白名单都取自**活动清单**:技能提及的工具不在本活动白名单者不可调,
   * 装配前查扩权 —— 载方法,不载权力(AM 08)。
   */
  const skills = createSkillEngineService({
    catalog: {
      skillsOf: async (activityId) => [...(await registry.manifestOf(activityId)).assets.skills],
      allowlistOf: async (activityId) =>
        (await registry.manifestOf(activityId)).declarations.tools.map((t) => t.name),
    },
    tools: {
      invoke: (input) => toolInvoker.invoke(input),
    },
    memory: {
      append: async (input) =>
        void (await memory.append({
          ...input,
          stamp: { contractVersion: '1', businessModelVersion: '1', skillVersions: [] },
        })),
    },
    clock: systemClock,
  });

  const release = createReleaseService({
    intents: createIntentStore(db),
    ledger: {
      checkConflicts: async (taskId) =>
        (await ledger.checkConflicts(taskId)).map((c) => ({ field: c.field, key: c.key })),
      releaseWrite: (taskId) => ledger.releaseWrite(taskId),
    },
    tools: {
      isInvocable: async (tool, activityId) => {
        const contract = await toolbox.get(tool);
        if (contract === undefined) return { ok: false, reason: `工具未注册:${tool}` };
        const allowlist = await toolbox.allowlistOf(activityId);
        if (contract.pure !== true && !allowlist.includes(tool)) {
          return { ok: false, reason: `工具不在本活动白名单:${tool}` };
        }
        return { ok: true };
      },
      validateInput: async (tool, input) => {
        const contract = await toolbox.get(tool);
        if (contract === undefined) return { ok: false, errors: [`工具未注册:${tool}`] };
        return schemas.validate(contract.input, input);
      },
      validateTarget: async (input) => {
        const result = await toolInvoker.validate({ tool: input.tool, input: input.payload, activityId: input.activityId, taskId: input.taskId });
        if (result === undefined) return undefined;
        return { ok: result.ok, ...(result.error === undefined ? {} : { error: result.error.message }) };
      },
      execute: async (input) => {
        const result = await toolInvoker.invoke({
          tool: input.tool,
          input: input.payload,
          activityId: input.activityId,
          taskId: input.taskId,
        });
        return {
          id: input.idempotencyKey,
          ok: result.ok,
          ...(result.error === undefined ? {} : { error: result.error.message }),
          retryable: result.error?.retryable ?? false,
        };
      },
    },
    cards: {
      issueAcceptance: async (input) => {
        const issued = await humanTool.issueAcceptance(
          { taskId: input.taskId, ownerId: input.ownerId, humanCallCap: input.humanCallCap },
          {
            title: input.title,
            basis: [...input.basis],
            deliverable: input.deliverable as never,
            criteria: [...input.criteria],
            actions: input.actions.map((a) => ({ ...a })),
            fields: [],
          },
        );
        return { id: issued.order.id };
      },
      issueLandingFailure: async (input) => {
        const issued = await humanTool.issueLandingFailure(
          { taskId: input.taskId, ownerId: input.ownerId, humanCallCap: input.humanCallCap },
          { failures: input.failures },
        );
        return { id: issued.order.id };
      },
    },
    tasks: {
      activityIdOf: async (taskId) => (await engines.task.get(taskId)).activityId,
      outputPortsOf: async (taskId) => {
        const task = await engines.task.get(taskId);
        const manifest = await registry.manifestOf(task.activityId);
        return {
          mandatory: manifest.contract.output.mandatory.map((p) => p.name),
          selective: manifest.contract.output.selective.map((g) => ({
            group: g.group,
            ports: g.ports.map((p) => p.name),
          })),
        };
      },
    },
    ports: {
      emit: async (input) => {
        // 落地收敛才发射 —— 下游只见落地完成的任务
        await event.publish({
          type: 'data',
          correlation: {
            target: { kind: 'task', id: input.taskId },
            cause: { kind: 'engine', ref: 'output-port' },
            keys: { port: input.port },
          },
          payload: { data: input.payload },
          occurredAt: systemClock.now().toISOString(),
          source: { kind: 'engine', detail: 'release' },
        });
      },
    },
    memory: {
      append: async (input) =>
        void (await memory.append({
          ...input,
          stamp: { contractVersion: '1', businessModelVersion: '1', skillVersions: [] },
        })),
    },
    clock: systemClock,
    ids,
  });

  /* ── L5–L7:范式引擎、任务、流程层 ─────────────────────────────── */

  const engines = wireEngines({
    db,
    clock: systemClock,
    ids,
    event,
    ledger,
    memory,
    toolbox,
    toolInvoker,
    humanTool,
    interaction,
    message,
    org,
    llm,
    modelGateway,
    registry,
    release,
    skills,
    schemas,
  });

  // 停用前置检查的真身就位:在途任务问 task,待答卡问 human-tool
  inFlightProbe.bind({
    openTasksOf: (staffId) => engines.task.openTasksOf(staffId),
    openCardsOf: (staffId) => humanTool.openCardsOf(staffId),
    openApprovalsOf: async () => [],
  });

  // 触发器就位后回填 —— event 的三级消费自此真判定
  triggerMatcher.bind({
    match: (envelope) =>
      engines.trigger.match({
        type: envelope.type,
        keys: envelope.correlation.keys,
        payload: envelope.payload.data,
        source: envelope.source.kind,
        occurredAt: envelope.occurredAt,
      }),
  });

  // L8:工作台后两个要素 —— 只读 memory 与 task 的投影,一行都不另记
  const deskElements = wireDeskElements({
    db,
    memory,
    task: engines.task,
    org,
    process: engines.process,
    ids,
    clock: systemClock,
  });

  return {
    config,
    broadcaster: createBroadcaster(),
    pool,
    db,
    org,
    ledger,
    event,
    llm,
    modelGateway,
    memory,
    toolbox,
    toolInvoker,
    message,
    channel,
    humanTool,
    interaction,
    registry,
    release,
    task: engines.task,
    process: engines.process,
    trigger: engines.trigger,
    minute: deskElements.minute,
    report: deskElements.report,
    async close() {
      await pool.end();
    },
  };
}