/**
 * 活动包的自测 —— **只准 import @sdk / @contracts 与白名单纯库**(编码规范 §5.1 / ADR-004)。
 * 安装两审那一侧的验收在 `apps/api/.../activity-registry/__tests__` —— 二者之间只有安装通道,
 * 没有代码通道,depcruise 双向隔离在守着。
 */
import { describe, expect, it } from 'vitest';
import { activityManifestSchema } from '@contracts';
import { evaluateUnaryTest } from '@sfeel';
import { createMockHost } from '@sdk';
import { manifest, P03_DMN } from '../src/manifest.ts';
import activity from '../src/index.ts';

describe('清单本身合规', () => {
  it('过 @contracts 的 schema', () => {
    expect(() => activityManifestSchema.parse(manifest)).not.toThrow();
  });

  it('监听时限已配 —— 无悬空监听(AM 4.4)', () => {
    expect(manifest.declarations.listeners.every((l) => /^P/.test(l.deadline))).toBe(true);
  });

  it('L1/L2 判据都给了可机检的谓词 —— 验收等级不得谎报', () => {
    for (const c of manifest.contract.acceptanceCriteria) {
      if (c.level === 'L1' || c.level === 'L2') expect(c.predicate ?? c.modelRef).toBeDefined();
    }
  });

  it('禁区短而硬,授权边界给了调人预算', () => {
    expect(manifest.contract.prohibitions.length).toBeGreaterThan(0);
    expect(manifest.contract.authorization.humanCallBudget).toBeGreaterThan(0);
  });
});

describe('案例模型(AM 03/12.2)—— 双表示同版本', () => {
  const model = manifest.assets.businessModel;
  const cmmn = parseCmmnLite(model.cmmnXml);

  it('CMMN 与说明书同在,不允许分叉', () => {
    expect(model.cmmnXml).toContain('<casePlanModel');
    expect(model.narrative.length).toBeGreaterThan(80);
  });

  it('触达世界的项恒需人工激活(AM 4.1 原理一)', () => {
    // 解析归一、追问补全、查历史价 —— 三件都碰外界,一件也不许自动跑
    for (const id of ['T_normalize', 'T_ask_back', 'T_history']) {
      expect(cmmn.manualActivation, `${id} 应为人工激活`).toContain(id);
    }
  });

  it('末尾一张验收单 —— 完成只出自放行通过', () => {
    expect(model.cmmnXml).toContain('id="T_release"');
  });

  it('能算的交 DMN,不交 Agent —— 打标是 decisionTask', () => {
    expect(model.cmmnXml).toContain('decisionRef="p03-type"');
    expect(P03_DMN.tables.some((t) => t.id === 'p03-type')).toBe(true);
  });
});

/** 极小取值:只为断言用,不重实现引擎的解析器(那一份在 loop-engine 里有自己的测试) */
function parseCmmnLite(xml: string): { manualActivation: string[] } {
  const ids: string[] = [];
  for (const m of xml.matchAll(/<humanTask id="([^"]+)"[\s\S]*?<\/humanTask>/g)) {
    if (m[0].includes('manualActivationRule')) ids.push(m[1]!);
  }
  return { manualActivation: ids };
}

describe('三分类规则 P-03 —— 能算的不问 LLM', () => {
  const table = P03_DMN.tables[0]!;

  /** 按 DMN 语义逐行求值:FIRST 命中即定,单元格谓词复用 @sfeel */
  const decide = (scope: Record<string, unknown>) => {
    for (const rule of table.rules) {
      const hit = table.inputs.every((input, i) => evaluateUnaryTest(rule.when[i] ?? '-', scope[input.expression], scope));
      if (hit) return { type: rule.then[0], play: rule.then[1], rule: rule.id };
    }
    return undefined;
  };

  it('历史价 ≤90 天且行情稳 → A · 直接快答', () => {
    expect(decide({ historyDays: 30, marketStable: true, lifecycle: '在产' })).toEqual({
      type: 'A',
      play: '直接快答',
      rule: 'p03-a',
    });
  });

  it('无历史 / 过期 / 波动 → B · 重估后报', () => {
    expect(decide({ historyDays: 200, marketStable: false, lifecycle: '在产' })?.type).toBe('B');
  });

  it('EOL / 缺货 / 要求替代 → C · 转案处理(优先于 A)', () => {
    expect(decide({ historyDays: 10, marketStable: true, lifecycle: 'EOL' })).toMatchObject({ type: 'C', rule: 'p03-c' });
  });

  it('同输入必同结论 —— 零方差、零 token', () => {
    const scope = { historyDays: 30, marketStable: true, lifecycle: '在产' };
    expect(decide(scope)).toEqual(decide(scope));
  });
});

describe('代码入口 —— 零环境能力,一切经基座六件', () => {
  const contract = {
    activityId: 'quote-intake',
    version: '0.1.0',
    data: { customerCode: 'C001', rfqRef: 'mail:m-1001' },
    message: undefined,
    outputPorts: { mandatory: ['intake'], selective: [] },
    prohibitions: [],
    discretion: [],
  } as const;

  it('全部打标后提交放行', async () => {
    const host = createMockHost({
      contract,
      ledger: {
        'quote_intake.record': [
          { customer_code: 'C001', pn: 'LM358DR', brand: 'TI', eau: 5000, type_tag: 'A' },
          { customer_code: 'C001', pn: 'NE555', brand: 'TI', eau: 2000, type_tag: 'B' },
        ],
        'quote_intake.type_table': [{ pn: 'LM358DR', type_tag: 'A' }],
      },
    });
    const outcome = await host.run(activity);
    expect(outcome).toMatchObject({ kind: 'submit', deliverable: 'intake-record' });
    expect(host.recording.views).toHaveLength(1);
    expect(host.recording.says.join()).toContain('A 1 条直通定价');
  });

  it('尚有未打标即等待,不提交放行', async () => {
    const host = createMockHost({
      contract,
      ledger: { 'quote_intake.record': [{ customer_code: 'C001', pn: 'LM358DR' }], 'quote_intake.type_table': [] },
    });
    expect(await host.run(activity)).toMatchObject({ kind: 'await' });
  });

  it('视图模版含脚本时宿主拒推 —— 容器无脚本执行权', async () => {
    const host = createMockHost({ contract });
    await expect(host.base.interaction.pushHtml('<div><script>x()</script></div>')).rejects.toThrow(/无脚本执行权/);
  });

  it('裸调用被基座拒发 —— 调用必附上下文', async () => {
    const host = createMockHost({ contract });
    await expect(
      host.base.interaction.issueWorkOrder({ mode: 'execution', title: 'x', basis: [], ask: 'y', fields: [] }),
    ).rejects.toThrow(/裸调用/);
  });

  it('监听时限必配 —— 无死等', async () => {
    const host = createMockHost({ contract });
    await expect(host.base.tools.listen({ eventType: 'data', keyFilter: {}, deadline: '' })).rejects.toThrow(/时限必配/);
  });
});