import { describe, expect, it } from 'vitest'
import {
  createBinding,
  createDefinitionDraft,
  createEmptyDraft,
  defaultNodeConfig,
  describeActorRules,
  describeApprovalMode,
  describeCondition,
  draftToCanvasJson,
  draftToSavePayload,
  duplicateLinearStep,
  insertLinearStep,
  inspectLinear,
  listLinearSteps,
  logicFlowToWorkflowDraft,
  moveLinearStep,
  normalizeCondition,
  normalizeEdgePriorities,
  outgoingEdgesOf,
  removeLinearStep,
  rowsToWorkflowDraft,
  treeSignature,
  validateWorkflowDomain,
  workflowDraftToTree,
  workflowDomainToLogicFlow,
  workflowTreeToDraft,
} from '@/views/system/workflow/designer/domain'

/** 造一份「开始 → 人工审批 → 结束」的线性草稿 */
function linearDraft() {
  return createDefinitionDraft({
    id: 'expense_approval',
    name: '费用报销审批',
    moduleId: 'cw_expense',
    event: 'submit',
  })
}

/** 取校验结果里的错误文案，便于断言 */
function errorsOf(draft, options) {
  return validateWorkflowDomain(draft, options)
    .filter((issue) => issue.level === 'error')
    .map((issue) => issue.message)
}

describe('领域草稿（schemaVersion 2）', () => {
  it('空草稿自带开始与结束节点，并用一条默认连线串起来', () => {
    const draft = createEmptyDraft()
    expect(draft.schemaVersion).toBe(2)
    expect(draft.nodes.map((node) => node.nodeKey)).toEqual(['start', 'end'])
    expect(draft.edges).toHaveLength(1)
    expect(draft.edges[0]).toMatchObject({ from: 'start', to: 'end', condition: null })
    expect(draft.definition).toEqual({ id: '', name: '', i18n: null, enabled: true, remark: '' })
    expect(draft.bindings).toEqual([])
  })

  it('新建向导的默认模板是「开始 → 人工审批 → 结束」，审批人留空', () => {
    const draft = linearDraft()
    expect(draft.definition.id).toBe('expense_approval')
    expect(draft.nodes.map((node) => node.nodeType)).toEqual(['start', 'user_task', 'end'])
    expect(draft.nodes[1].actorRules).toEqual([])
    expect(draft.edges.map((edge) => [edge.from, edge.to])).toEqual([
      ['start', 'user_task_1'],
      ['user_task_1', 'end'],
    ])
    expect(draft.bindings[0]).toMatchObject({ moduleId: 'cw_expense', event: 'submit', enabled: true })
  })

  it('不用模板时只给空白高级流程', () => {
    const draft = createDefinitionDraft({ id: 'x', name: 'X', moduleId: 'm', useTemplate: false })
    expect(draft.nodes.map((node) => node.nodeType)).toEqual(['start', 'end'])
  })

  it('抄送节点不带审批设置，只配抄送人规则（§5.3）', () => {
    const result = insertLinearStep(linearDraft(), 'start', 'cc_task')
    const cc = result.draft.nodes.find((node) => node.nodeKey === result.nodeKey)
    expect(cc.config).toEqual({})
  })
})

describe('条件 AST 的空值归一', () => {
  it('空逻辑组会被归一成 null（默认出口），但带一条条件行的组会保留', () => {
    expect(normalizeCondition({ all: [] })).toBeNull()
    expect(normalizeCondition(null)).toBeNull()
    const group = { all: [{ field: '', operator: 'like', value: undefined }] }
    expect(normalizeCondition(group)).toEqual(group)
  })

  it('抄送发起人自己不算自审风险，只有人工审批节点才算（§9.2）', () => {
    const draft = linearDraft()
    const withCc = insertLinearStep(draft, 'start', 'cc_task')
    const ccKey = withCc.nodeKey
    const ccDraft = {
      ...withCc.draft,
      nodes: withCc.draft.nodes.map((node) =>
        node.nodeKey === ccKey
          ? { ...node, actorRules: [{ actorType: 'initiator', actorRef: '' }] }
          : node,
      ),
    }
    const warnings = validateWorkflowDomain(ccDraft)
      .filter((issue) => issue.level === 'warn')
      .map((issue) => issue.message)
    expect(warnings.some((message) => message.includes('允许申请人自审'))).toBe(false)
  })
})

describe('数据库行 → 领域草稿', () => {
  const rows = {
    definition: { b_id: 'expense_approval', b_name: '费用报销审批', b_canuse: 1, b_bz: '备注' },
    version: {
      b_id: 'expense_approval_v3',
      b_definition_id: 'expense_approval',
      b_version_no: 3,
      b_status: 'draft',
      b_canvas_json: '{"zoom":1,"nodes":{"start":{"x":100,"y":200}}}',
    },
    bindings: [
      {
        b_id: 'bind_1',
        b_module_id: 'cw_expense',
        b_event: 'submit',
        b_priority: 5,
        b_canuse: 1,
        b_match_json: '{"all":[]}',
      },
    ],
    nodes: [
      {
        b_node_key: 'start',
        b_node_type: 'start',
        b_name: '开始',
        b_config_json: null,
      },
      {
        b_node_key: 'dept_manager',
        b_node_type: 'user_task',
        b_name: '部门负责人审批',
        b_approval_mode: 'all',
        b_reject_mode: 'return_initiator',
        b_due_hours: 24,
        b_config_json: '{"requiredCount":2,"allowClaim":true,"commentRequired":true}',
      },
    ],
    edges: [
      {
        b_id: 'e1',
        b_from_node_key: 'start',
        b_to_node_key: 'dept_manager',
        b_name: null,
        b_condition_json: '{"all":[{"field":"b_amount","operator":"gt","value":10000}]}',
      },
    ],
    actorRules: [
      { b_node_key: 'dept_manager', b_actor_type: 'user', b_actor_ref: 'u1', b_priority: 10 },
      { b_node_key: 'dept_manager', b_actor_type: 'dept_manager', b_actor_ref: '', b_priority: 20 },
    ],
  }

  it('拆出定义、版本与绑定', () => {
    const draft = rowsToWorkflowDraft(rows)
    expect(draft.schemaVersion).toBe(2)
    expect(draft.definition).toMatchObject({ id: 'expense_approval', name: '费用报销审批', enabled: true })
    expect(draft.version).toMatchObject({ id: 'expense_approval_v3', versionNo: 3, status: 'draft' })
    expect(draft.bindings[0]).toMatchObject({ id: 'bind_1', moduleId: 'cw_expense', event: 'submit', priority: 5 })
  })

  it('坐标从 b_canvas_json 读回，缺失的节点用默认落点', () => {
    const draft = rowsToWorkflowDraft(rows)
    const start = draft.nodes.find((node) => node.nodeKey === 'start')
    const task = draft.nodes.find((node) => node.nodeKey === 'dept_manager')
    expect([start.x, start.y]).toEqual([100, 200])
    expect(Number.isFinite(task.x)).toBe(true)
    expect(task.y).toBe(240)
  })

  it('列上的审批设置优先于 b_config_json，其余低频配置保留在 config 里', () => {
    const task = rowsToWorkflowDraft(rows).nodes.find((node) => node.nodeKey === 'dept_manager')
    expect(task.config).toMatchObject({
      approvalMode: 'all',
      rejectMode: 'return_initiator',
      dueHours: 24,
      requiredCount: 2,
      allowClaim: true,
      commentRequired: true,
    })
  })

  it('审批人规则按节点分组并保留顺序（串行会签顺序来源）', () => {
    const task = rowsToWorkflowDraft(rows).nodes.find((node) => node.nodeKey === 'dept_manager')
    expect(task.actorRules.map((rule) => rule.actorType)).toEqual(['user', 'dept_manager'])
    expect(task.actorRules[0].actorRef).toBe('u1')
    expect(task.actorRules[0].fallbackType).toBe('none')
  })

  it('连线条件解析为结构化 AST', () => {
    const edge = rowsToWorkflowDraft(rows).edges[0]
    expect(edge.edgeKey).toBe('e1')
    expect(edge.condition).toEqual({ all: [{ field: 'b_amount', operator: 'gt', value: 10000 }] })
  })

  it('脏 JSON 不让设计器打不开', () => {
    const draft = rowsToWorkflowDraft({
      ...rows,
      version: { ...rows.version, b_canvas_json: '{坏数据' },
      nodes: [{ ...rows.nodes[1], b_config_json: 'not-json' }],
    })
    expect(draft.nodes[0].config.approvalMode).toBe('all')
  })
})

describe('领域草稿 → 落库载荷', () => {
  it('坐标只进 canvas，不写进节点行', () => {
    const draft = linearDraft()
    draft.nodes[1].x = 333
    draft.nodes[1].y = 444
    const payload = draftToSavePayload(draft)
    const taskRow = payload.nodes.find((row) => row.b_node_key === 'user_task_1')
    expect(taskRow).not.toHaveProperty('x')
    expect(taskRow).not.toHaveProperty('b_canvas_json')
    expect(payload.canvas.nodes.user_task_1).toEqual({ x: 333, y: 444 })
  })

  it('审批方式、驳回策略、时限走列，低频配置走 b_config_json 且不重复', () => {
    const draft = linearDraft()
    const task = draft.nodes[1]
    task.config.approvalMode = 'n_of_m'
    task.config.requiredCount = 2
    task.config.allowClaim = true

    const row = draftToSavePayload(draft).nodes.find((item) => item.b_node_key === 'user_task_1')
    expect(row.b_approval_mode).toBe('n_of_m')
    expect(row.b_reject_mode).toBe('terminate')
    expect(row.b_due_hours).toBeNull()

    const config = JSON.parse(row.b_config_json)
    expect(config.requiredCount).toBe(2)
    expect(config.allowClaim).toBe(true)
    expect(config).not.toHaveProperty('approvalMode')
    expect(config).not.toHaveProperty('rejectMode')
    expect(config).not.toHaveProperty('dueHours')
  })

  it('审批人规则拆平为 wf_actor_rule 行并用 b_priority 保存顺序', () => {
    const draft = linearDraft()
    draft.nodes[1].actorRules = [
      { actorType: 'dept_manager', actorRef: 'initiator_dept', fallbackType: 'none' },
      { actorType: 'user', actorRef: 'u9', fallbackType: 'admin' },
    ]
    const rules = draftToSavePayload(draft).actor_rules
    expect(rules).toHaveLength(2)
    expect(rules[0]).toMatchObject({ b_node_key: 'user_task_1', b_actor_type: 'dept_manager', b_priority: 10 })
    expect(rules[1]).toMatchObject({ b_actor_type: 'user', b_actor_ref: 'u9', b_priority: 20 })
  })

  it('画布布局只保留坐标', () => {
    const draft = linearDraft()
    const canvas = draftToCanvasJson(draft)
    expect(canvas.zoom).toBe(1)
    expect(Object.keys(canvas.nodes)).toEqual(['start', 'user_task_1', 'end'])
  })
})

describe('领域草稿 ↔ 画布模型', () => {
  it('渲染到画布时带上领域类型与条件摘要标签', () => {
    const draft = linearDraft()
    draft.edges[0].condition = { all: [{ field: 'b_amount', operator: 'gt', value: 10000 }] }
    const graph = workflowDomainToLogicFlow(draft)
    expect(graph.nodes.map((node) => node.type)).toEqual(['fms-start', 'fms-user-task', 'fms-end'])
    expect(graph.nodes[1].id).toBe('user_task_1')
    expect(graph.edges[0].text).toBe('b_amount 大于 10000')
  })

  it('从画布合并回草稿时保留业务配置（画布不承载审批设置）', () => {
    const draft = linearDraft()
    draft.nodes[1].config.approvalMode = 'serial'
    draft.nodes[1].actorRules = [{ actorType: 'user', actorRef: 'u1' }]

    // 画布只回传结构：多了一个节点、节点被移动、文本被改
    const graph = {
      nodes: [
        { id: 'start', type: 'fms-start', x: 10, y: 20, text: '开始' },
        { id: 'user_task_1', type: 'fms-user-task', x: 300, y: 120, text: '部门负责人' },
        { id: 'user_task_2', type: 'fms-user-task', x: 500, y: 120, text: '人工审批' },
        { id: 'end', type: 'fms-end', x: 700, y: 120, text: '结束' },
      ],
      edges: [
        { id: 'edge_1', sourceNodeId: 'start', targetNodeId: 'user_task_1' },
        { id: 'edge_2', sourceNodeId: 'user_task_1', targetNodeId: 'user_task_2' },
        { id: 'edge_3', sourceNodeId: 'user_task_2', targetNodeId: 'end' },
      ],
    }

    const merged = logicFlowToWorkflowDraft(graph, draft)
    const kept = merged.nodes.find((node) => node.nodeKey === 'user_task_1')
    expect(kept.config.approvalMode).toBe('serial')
    expect(kept.actorRules).toEqual([{ actorType: 'user', actorRef: 'u1' }])
    expect([kept.x, kept.y]).toEqual([300, 120])
    expect(kept.name).toBe('部门负责人')
    // 新节点拿到默认配置，不会继承别人的审批人
    const added = merged.nodes.find((node) => node.nodeKey === 'user_task_2')
    expect(added.actorRules).toEqual([])
    expect(merged.edges).toHaveLength(3)
    expect(merged.definition.id).toBe('expense_approval')
  })
})

/** 字段编码 → 显示名，模拟从 s_field 取 b_name */
const fieldNameOf = (code) => (code === 'b_amount' ? '金额' : code)

describe('条件 AST 摘要', () => {
  it('无条件时不给标签（默认出口）', () => {
    expect(describeCondition(null)).toBe('')
  })

  it('叶子条件用操作符文案拼一句话', () => {
    expect(describeCondition({ field: 'b_amount', operator: 'gt', value: 10000 })).toBe(
      'b_amount 大于 10000',
    )
  })

  it('无值操作符不带比较值', () => {
    expect(describeCondition({ all: [{ field: 'b_reason', operator: 'is_null' }] })).toBe(
      'b_reason 为空',
    )
  })

  it('区间与多值操作符按各自形态展示', () => {
    expect(
      describeCondition({ all: [{ field: 'b_amount', operator: 'between', value: [1, 9] }] }),
    ).toBe('b_amount 介于 1 ~ 9')
    expect(
      describeCondition({ all: [{ field: 'b_status', operator: 'in', value: ['a', 'b'] }] }),
    ).toBe('b_status 属于 a、b')
  })

  it('all / any 用且或连接，嵌套组加括号', () => {
    expect(
      describeCondition({
        all: [
          { field: 'b_amount', operator: 'gt', value: 10000 },
          { field: 'b_company', operator: 'eq', value: '华东' },
        ],
      }),
    ).toBe('b_amount 大于 10000 且 b_company 等于 华东')

    expect(
      describeCondition({
        any: [
          { field: 'a', operator: 'eq', value: 1 },
          { any: [{ field: 'b', operator: 'eq', value: 2 }, { field: 'c', operator: 'eq', value: 3 }] },
        ],
      }),
    ).toBe('a 等于 1 或 （b 等于 2 或 c 等于 3）')
  })

  it('可以按 s_field 把字段编码换成显示名', () => {
    expect(
      describeCondition({ all: [{ field: 'b_amount', operator: 'gt', value: 1 }] }, { fieldName: fieldNameOf }),
    ).toBe('金额 大于 1')
  })
})

describe('单链路判定与卡片模式图操作', () => {
  it('线性草稿可以进卡片模式，并给出主链路顺序', () => {
    const info = inspectLinear(linearDraft())
    expect(info.linear).toBe(true)
    expect(info.order).toEqual(['start', 'user_task_1', 'end'])
  })

  it('含条件分支的流程不能进卡片模式，并说明原因', () => {
    const draft = linearDraft()
    draft.nodes.push({
      nodeKey: 'gw_1',
      nodeType: 'exclusive_gateway',
      name: '条件分支',
      x: 0,
      y: 0,
      config: {},
      actorRules: [],
    })
    const info = inspectLinear(draft)
    expect(info.linear).toBe(false)
    expect(info.reason).toContain('条件分支')
    expect(listLinearSteps(draft)).toEqual([])
  })

  it('插入节点：A → B 变成 A → 新节点 → B', () => {
    const result = insertLinearStep(linearDraft(), 'start', 'cc_task')
    expect(result.ok).toBe(true)
    const info = inspectLinear(result.draft)
    expect(info.order).toEqual(['start', result.nodeKey, 'user_task_1', 'end'])
    expect(result.nodeKey).toBe('cc_task_1')
  })

  it('插入节点的落点取前后节点的中点，不会叠在画布同一处', () => {
    const draft = linearDraft()
    draft.nodes[0].x = 100
    draft.nodes[0].y = 100
    draft.nodes[1].x = 300
    draft.nodes[1].y = 200
    const result = insertLinearStep(draft, 'start', 'user_task')
    const node = result.draft.nodes.find((item) => item.nodeKey === result.nodeKey)
    expect(node.x).toBe(200)
    expect(node.y).toBe(190)
  })

  it('删除节点：A → B → C 变成 A → C，开始与结束不可删', () => {
    const result = removeLinearStep(linearDraft(), 'user_task_1')
    expect(result.ok).toBe(true)
    expect(result.draft.nodes.map((node) => node.nodeKey)).toEqual(['start', 'end'])
    expect(result.draft.edges).toHaveLength(1)
    expect(result.draft.edges[0]).toMatchObject({ from: 'start', to: 'end' })

    expect(removeLinearStep(linearDraft(), 'start').ok).toBe(false)
    expect(removeLinearStep(linearDraft(), 'end').ok).toBe(false)
  })

  it('上移下移只改主链路顺序，连线数量不变', () => {
    const draft = linearDraft()
    const added = insertLinearStep(draft, 'start', 'cc_task').draft
    const info = inspectLinear(added)
    const moved = moveLinearStep(added, info.order[1], 1)
    expect(moved.ok).toBe(true)
    expect(inspectLinear(moved.draft).order).toEqual(['start', 'user_task_1', 'cc_task_1', 'end'])
    expect(moved.draft.edges).toHaveLength(3)
  })

  it('开始与结束节点不能换位', () => {
    expect(moveLinearStep(linearDraft(), 'start', 1).ok).toBe(false)
    expect(moveLinearStep(linearDraft(), 'end', -1).ok).toBe(false)
  })

  it('复制节点带上配置与审批人规则，编码重新生成', () => {
    const draft = linearDraft()
    draft.nodes[1].actorRules = [{ actorType: 'user', actorRef: 'u1' }]
    draft.nodes[1].config.commentRequired = true

    const result = duplicateLinearStep(draft, 'user_task_1')
    expect(result.ok).toBe(true)
    const clone = result.draft.nodes.find((node) => node.nodeKey === result.nodeKey)
    expect(clone.actorRules).toEqual([{ actorType: 'user', actorRef: 'u1' }])
    expect(clone.config.commentRequired).toBe(true)
    expect(clone.name).toContain('副本')
    // 两份规则不是同一个引用，改副本不影响原节点
    expect(clone.actorRules).not.toBe(draft.nodes[1].actorRules)
    expect(inspectLinear(result.draft).order).toEqual(['start', 'user_task_1', result.nodeKey, 'end'])
  })

  it('非单链路时所有图操作都拒绝并给出原因', () => {
    const draft = linearDraft()
    draft.nodes.push({
      nodeKey: 'gw_1',
      nodeType: 'exclusive_gateway',
      name: '条件分支',
      x: 0,
      y: 0,
      config: {},
      actorRules: [],
    })
    for (const result of [
      insertLinearStep(draft, 'start', 'cc_task'),
      removeLinearStep(draft, 'user_task_1'),
      moveLinearStep(draft, 'user_task_1', 1),
      duplicateLinearStep(draft, 'user_task_1'),
    ]) {
      expect(result.ok).toBe(false)
      expect(result.reason).toBeTruthy()
    }
  })
})

describe('节点摘要（卡片模式）', () => {
  it('审批方式带 N 人通过 / 按比例的参数', () => {
    expect(describeApprovalMode({ config: { approvalMode: 'single' } })).toBe('单人审批')
    expect(describeApprovalMode({ config: { approvalMode: 'n_of_m', requiredCount: 2 } })).toBe(
      'N 人通过 · 2 人',
    )
    expect(describeApprovalMode({ config: { approvalMode: 'percentage', requiredRatio: 0.6 } })).toBe(
      '按比例通过 · 60%',
    )
  })

  it('审批人摘要：无参类型只显示类型，有参类型显示对象', () => {
    const node = {
      actorRules: [
        { actorType: 'dept_manager', actorRef: 'initiator_dept' },
        { actorType: 'user', actorRef: 'u1' },
        { actorType: 'initiator', actorRef: '' },
      ],
    }
    expect(describeActorRules(node, { nameOf: () => '张三' })).toBe(
      '部门负责人（发起人所属部门）、指定用户：张三、发起人',
    )
  })

  it('未选择对象时明确提示，不显示空值', () => {
    expect(describeActorRules({ actorRules: [{ actorType: 'user', actorRef: '' }] })).toBe(
      '指定用户：未选择',
    )
  })
})

describe('发布前校验', () => {
  it('默认模板缺审批人、缺绑定信息时逐条报错', () => {
    const draft = linearDraft()
    const errors = errorsOf(draft)
    expect(errors).toContain('「审批」未配置审批人规则')
    expect(errors.some((message) => message.includes('绑定 1'))).toBe(false)
  })

  it('没有绑定就不能发布', () => {
    const draft = linearDraft()
    draft.bindings = []
    expect(errorsOf(draft)).toContain('未配置流程绑定：流程无法被任何业务单据触发')
  })

  it('流程编码与名称必填', () => {
    const draft = linearDraft()
    draft.definition.id = ''
    draft.definition.name = '  '
    const errors = errorsOf(draft)
    expect(errors).toContain('流程编码为空')
    expect(errors).toContain('流程名称为空')
  })

  it('N 人通过与按比例通过必须给合法参数', () => {
    const draft = linearDraft()
    const task = draft.nodes[1]
    task.actorRules = [{ actorType: 'initiator', actorRef: '' }]
    task.config.allowInitiator = true
    task.config.approvalMode = 'n_of_m'
    expect(errorsOf(draft)).toContain('「审批」选择 N 人通过但未填写通过人数')

    task.config.approvalMode = 'percentage'
    task.config.requiredRatio = 1.5
    expect(errorsOf(draft)).toContain('「审批」的通过比例必须在 0 到 1 之间')
  })

  it('把发起人当审批人但未开自审时给警告（§9.2）', () => {
    const draft = linearDraft()
    draft.nodes[1].actorRules = [{ actorType: 'initiator', actorRef: '' }]
    const warnings = validateWorkflowDomain(draft)
      .filter((issue) => issue.level === 'warn')
      .map((issue) => issue.message)
    expect(warnings.some((message) => message.includes('允许申请人自审'))).toBe(true)
  })

  it('条件分支必须有默认出口', () => {
    const draft = linearDraft()
    draft.nodes = [
      draft.nodes[0],
      { nodeKey: 'gw_1', nodeType: 'exclusive_gateway', name: '金额判断', x: 0, y: 0, config: {}, actorRules: [] },
      draft.nodes[1],
      draft.nodes[2],
    ]
    draft.edges = [
      { edgeKey: 'e1', from: 'start', to: 'gw_1', name: '', condition: null },
      {
        edgeKey: 'e2',
        from: 'gw_1',
        to: 'user_task_1',
        name: '',
        condition: { all: [{ field: 'b_amount', operator: 'gt', value: 1 }] },
      },
      { edgeKey: 'e3', from: 'user_task_1', to: 'end', name: '', condition: null },
    ]
    expect(errorsOf(draft)).toContain('条件分支「金额判断」缺少默认出口（需且仅需一条无条件连线）')
  })

  it('条件字段必须来自绑定模块的 s_field', () => {
    const draft = linearDraft()
    draft.nodes[1].actorRules = [{ actorType: 'initiator', actorRef: '' }]
    draft.nodes[1].config.allowInitiator = true
    draft.edges[1].condition = { all: [{ field: 'b_unknown', operator: 'eq', value: 1 }] }
    expect(errorsOf(draft, { fieldCodes: ['b_amount'] })).toContain(
      '连线条件引用的字段 b_unknown 不在绑定模块的字段里',
    )
    // 不传字段清单时跳过字段存在性校验（前端拿不到 s_field 的场景）
    expect(errorsOf(draft)).not.toContain('连线条件引用的字段 b_unknown 不在绑定模块的字段里')
  })

  it('条件缺少比较值时报错', () => {
    const draft = linearDraft()
    draft.nodes[1].actorRules = [{ actorType: 'initiator', actorRef: '' }]
    draft.nodes[1].config.allowInitiator = true
    draft.edges[1].condition = { all: [{ field: 'b_amount', operator: 'gt', value: '' }] }
    expect(errorsOf(draft)).toContain('条件字段 b_amount 未填写比较值')
  })

  it('环形路径与无出口节点都报错', () => {
    const draft = linearDraft()
    draft.nodes[1].actorRules = [{ actorType: 'initiator', actorRef: '' }]
    draft.nodes[1].config.allowInitiator = true
    // 把结束节点摘掉，人工审批指向自己形成环
    draft.nodes = draft.nodes.slice(0, 2)
    draft.edges = [{ edgeKey: 'e1', from: 'user_task_1', to: 'user_task_1', name: '', condition: null }]
    const errors = errorsOf(draft)
    expect(errors).toContain('缺少结束节点')
    expect(errors.some((message) => message.includes('环形路径'))).toBe(true)
  })

  it('不可达节点给警告', () => {
    const draft = linearDraft()
    draft.nodes[1].actorRules = [{ actorType: 'initiator', actorRef: '' }]
    draft.nodes[1].config.allowInitiator = true
    draft.nodes.push({
      nodeKey: 'user_task_9',
      nodeType: 'user_task',
      name: '孤立节点',
      x: 0,
      y: 0,
      config: {},
      actorRules: [],
    })
    const warnings = validateWorkflowDomain(draft)
      .filter((issue) => issue.level === 'warn')
      .map((issue) => issue.message)
    expect(warnings).toContain('节点「孤立节点」从开始节点不可达')
  })

  it('同一模块同一事件多条启用绑定给出复核提示', () => {
    const draft = linearDraft()
    draft.nodes[1].actorRules = [{ actorType: 'initiator', actorRef: '' }]
    draft.nodes[1].config.allowInitiator = true
    draft.bindings.push({ ...draft.bindings[0], id: 'bind_2', priority: 1 })
    const warnings = validateWorkflowDomain(draft)
      .filter((issue) => issue.level === 'warn')
      .map((issue) => issue.message)
    expect(warnings.some((message) => message.includes('条启用绑定'))).toBe(true)
  })

  it('完全配置好的线性流程没有错误', () => {
    const draft = linearDraft()
    draft.nodes[1].actorRules = [{ actorType: 'dept_manager', actorRef: 'initiator_dept' }]
    expect(errorsOf(draft)).toEqual([])
  })
})

/* ============================================================================
   流程树投影与编译（《FMS审批流程设置器交互重构设计》§5.1 / §5.2）

   阶段 1 的 fixtures：线性、两个条件、三条件排序、分支后公共审批、嵌套条件，
   以及并行 / 缺默认出口 / 重复默认出口 / 环 / 交叉边这些必须被保护掉的拓扑。
   ============================================================================ */

/** 节点构造器：树投影只关心拓扑与条件，坐标与配置给默认值 */
const N = (nodeKey, nodeType, name) => ({
  nodeKey,
  nodeType,
  name: name || nodeKey,
  x: 0,
  y: 0,
  config: defaultNodeConfig(nodeType),
  actorRules: [],
})

/** 连线构造器 */
const E = (edgeKey, from, to, condition = null, priority = 1) => ({
  edgeKey,
  from,
  to,
  name: '',
  condition,
  priority,
})

const AMOUNT_GT_1W = { all: [{ field: 'b_amount', operator: 'gt', value: 10000 }] }
const AMOUNT_GT_5W = { all: [{ field: 'b_amount', operator: 'gt', value: 50000 }] }
const REGION_EAST = { all: [{ field: 'b_region', operator: 'eq', value: 'east' }] }

/** 组装一份可直接投影的草稿 */
function draftOf(nodes, edges) {
  const draft = createEmptyDraft()
  draft.definition = { id: 'expense_approval', name: '费用报销审批', i18n: null, enabled: true, remark: '' }
  draft.version = { id: 'expense_approval_v3', versionNo: 3, status: 'draft' }
  draft.bindings = [createBinding('cw_expense', 'submit')]
  draft.nodes = nodes
  draft.edges = edges
  return draft
}

/** 开始 → 审批 → 结束 */
function linearFixture() {
  return draftOf(
    [N('start', 'start'), N('user_task_1', 'user_task', '部门负责人审批'), N('end', 'end')],
    [E('e1', 'start', 'user_task_1'), E('e2', 'user_task_1', 'end')],
  )
}

/** 两个条件：金额大于 1 万走财务，其他情况抄送归档，两者在结束节点汇合 */
function branchFixture() {
  return draftOf(
    [
      N('start', 'start'),
      N('user_task_1', 'user_task', '部门负责人审批'),
      N('gw_1', 'exclusive_gateway', '金额判断'),
      N('user_task_2', 'user_task', '财务审批'),
      N('cc_1', 'cc_task', '抄送归档'),
      N('end', 'end'),
    ],
    [
      E('e1', 'start', 'user_task_1'),
      E('e2', 'user_task_1', 'gw_1'),
      E('e3', 'gw_1', 'user_task_2', AMOUNT_GT_1W, 1),
      E('e4', 'gw_1', 'cc_1', null, 2),
      E('e5', 'user_task_2', 'end'),
      E('e6', 'cc_1', 'end'),
    ],
  )
}

/** 三条分支汇入公共审批节点 join，再走结束 */
function mergeFixture() {
  return draftOf(
    [
      N('start', 'start'),
      N('gw_1', 'exclusive_gateway', '金额判断'),
      N('user_task_a', 'user_task', '财务审批'),
      N('user_task_b', 'user_task', '法务审批'),
      N('cc_c', 'cc_task', '抄送财务'),
      N('user_task_join', 'user_task', '总经理审批'),
      N('end', 'end'),
    ],
    [
      E('e1', 'start', 'gw_1'),
      E('e2', 'gw_1', 'user_task_a', AMOUNT_GT_1W, 1),
      E('e3', 'gw_1', 'user_task_b', AMOUNT_GT_5W, 2),
      E('e4', 'gw_1', 'cc_c', null, 3),
      E('e5', 'user_task_a', 'user_task_join'),
      E('e6', 'user_task_b', 'user_task_join'),
      E('e7', 'cc_c', 'user_task_join'),
      E('e8', 'user_task_join', 'end'),
    ],
  )
}

/** 嵌套条件：外层分支里再开一层条件 */
function nestedFixture() {
  return draftOf(
    [
      N('start', 'start'),
      N('gw_1', 'exclusive_gateway', '金额判断'),
      N('gw_2', 'exclusive_gateway', '区域判断'),
      N('user_task_x', 'user_task', '华东区审批'),
      N('user_task_y', 'user_task', '其他区审批'),
      N('end', 'end'),
    ],
    [
      E('e1', 'start', 'gw_1'),
      E('e2', 'gw_1', 'gw_2', AMOUNT_GT_1W, 1),
      E('e3', 'gw_1', 'user_task_y', null, 2),
      E('e4', 'gw_2', 'user_task_x', REGION_EAST, 1),
      E('e5', 'gw_2', 'end', null, 2),
      E('e6', 'user_task_x', 'end'),
      E('e7', 'user_task_y', 'end'),
    ],
  )
}

/** 并行网关：树形编辑器表达不了（§3.2） */
function parallelFixture() {
  return draftOf(
    [
      N('start', 'start'),
      N('pg_1', 'parallel_gateway', '并行分支'),
      N('user_task_a', 'user_task', '财务审批'),
      N('user_task_b', 'user_task', '法务审批'),
      N('end', 'end'),
    ],
    [
      E('e1', 'start', 'pg_1'),
      E('e2', 'pg_1', 'user_task_a'),
      E('e3', 'pg_1', 'user_task_b', null, 2),
      E('e4', 'user_task_a', 'end'),
      E('e5', 'user_task_b', 'end'),
    ],
  )
}

/** 缺少默认出口 */
function missingDefaultFixture() {
  return draftOf(
    [
      N('start', 'start'),
      N('gw_1', 'exclusive_gateway', '金额判断'),
      N('user_task_a', 'user_task', '财务审批'),
      N('user_task_b', 'user_task', '法务审批'),
      N('end', 'end'),
    ],
    [
      E('e1', 'start', 'gw_1'),
      E('e2', 'gw_1', 'user_task_a', AMOUNT_GT_1W, 1),
      E('e3', 'gw_1', 'user_task_b', AMOUNT_GT_5W, 2),
      E('e4', 'user_task_a', 'end'),
      E('e5', 'user_task_b', 'end'),
    ],
  )
}

/** 两条默认出口：显式条件全被清成 null */
function duplicateDefaultFixture() {
  const draft = missingDefaultFixture()
  draft.edges = draft.edges.map((edge) =>
    edge.edgeKey === 'e2' || edge.edgeKey === 'e3' ? { ...edge, condition: null } : edge,
  )
  return draft
}

/** 环：审批节点回连网关，网关因此有两条入线 */
function cycleFixture() {
  return draftOf(
    [
      N('start', 'start'),
      N('gw_1', 'exclusive_gateway', '金额判断'),
      N('user_task_a', 'user_task', '财务审批'),
      N('end', 'end'),
    ],
    [
      E('e1', 'start', 'gw_1'),
      E('e2', 'gw_1', 'user_task_a', AMOUNT_GT_1W, 1),
      E('e3', 'gw_1', 'end', null, 2),
      E('e4', 'user_task_a', 'gw_1'),
    ],
  )
}

/** 交叉边：B 落在 A 的专属路径里，又不是汇合点 */
function crossFixture() {
  return draftOf(
    [
      N('start', 'start'),
      N('gw_1', 'exclusive_gateway', '金额判断'),
      N('user_task_a', 'user_task', '财务审批'),
      N('user_task_b', 'user_task', '法务审批'),
      N('cc_c', 'cc_task', '抄送财务'),
      N('end', 'end'),
    ],
    [
      E('e1', 'start', 'gw_1'),
      E('e2', 'gw_1', 'user_task_a', AMOUNT_GT_1W, 1),
      E('e3', 'gw_1', 'user_task_b', AMOUNT_GT_5W, 2),
      E('e4', 'gw_1', 'cc_c', null, 3),
      E('e5', 'user_task_a', 'user_task_b'),
      E('e6', 'user_task_b', 'end'),
      E('e7', 'cc_c', 'end'),
    ],
  )
}

/** 校验结果里的全部文案 */
const messagesOf = (draft) => validateWorkflowDomain(draft).map((item) => item.message)

/** 取树的路径，便于断言 */
function pathOf(tree) {
  const keys = []
  let item = tree
  while (item) {
    keys.push(item.kind === 'branch' ? item.gatewayKey : item.nodeKey)
    item = item.next
  }
  return keys
}

/** 连线按编码建索引：编译产出的数组是后序，顺序与草稿不同但语义无差别 */
function edgeMapOf(draft) {
  return Object.fromEntries(
    normalizeEdgePriorities(draft.edges).map((edge) => [
      edge.edgeKey,
      { from: edge.from, to: edge.to, priority: edge.priority, condition: edge.condition },
    ]),
  )
}

describe('流程树投影：可表达的拓扑', () => {
  it('线性流程投影成一条 step 链', () => {
    const result = workflowDraftToTree(linearFixture())
    expect(result.ok).toBe(true)
    expect(pathOf(result.tree)).toEqual(['start', 'user_task_1', 'end'])
    expect(result.tree.next.next.next).toBeNull()
  })

  it('两个条件：显式条件在前，「其他情况」固定最后，child 与 next 各归各位', () => {
    const result = workflowDraftToTree(branchFixture())
    expect(result.ok).toBe(true)

    const branch = result.tree.next.next
    expect(branch.kind).toBe('branch')
    expect(branch.gatewayKey).toBe('gw_1')
    expect(branch.branches.map((item) => item.edgeKey)).toEqual(['e3', 'e4'])
    expect(branch.branches.map((item) => item.priority)).toEqual([1, 2])
    expect(branch.branches[0].condition).toEqual(AMOUNT_GT_1W)
    expect(branch.branches[1].condition).toBeNull()
    expect(branch.branches[0].child).toEqual({ kind: 'step', nodeKey: 'user_task_2', next: null })
    expect(branch.branches[1].child).toEqual({ kind: 'step', nodeKey: 'cc_1', next: null })
    // 两条分支在结束节点汇合，结束只渲染一次
    expect(pathOf(branch.next)).toEqual(['end'])
  })

  it('三条件按 b_priority 排序，默认出口即使优先级最大也固定最后', () => {
    const draft = mergeFixture()
    // 打乱优先级：法务 1、抄送 2、财务 3
    draft.edges = draft.edges.map((edge) => {
      if (edge.edgeKey === 'e2') return { ...edge, priority: 3 }
      if (edge.edgeKey === 'e3') return { ...edge, priority: 1 }
      if (edge.edgeKey === 'e4') return { ...edge, priority: 2 }
      return edge
    })

    const result = workflowDraftToTree(draft)
    expect(result.ok).toBe(true)
    const branch = result.tree.next
    expect(branch.branches.map((item) => item.edgeKey)).toEqual(['e3', 'e2', 'e4'])
    // 投影里的优先级归一化成显示顺序
    expect(branch.branches.map((item) => item.priority)).toEqual([1, 2, 3])
    expect(branch.branches[2].condition).toBeNull()
  })

  it('分支后公共审批：三条分支各自独立，next 指向汇合点', () => {
    const result = workflowDraftToTree(mergeFixture())
    expect(result.ok).toBe(true)

    const branch = result.tree.next
    expect(branch.kind).toBe('branch')
    expect(branch.branches.map((item) => item.child?.nodeKey)).toEqual([
      'user_task_a',
      'user_task_b',
      'cc_c',
    ])
    expect(pathOf(branch.next)).toEqual(['user_task_join', 'end'])
  })

  it('嵌套条件：内层条件块成为外层分支的 child', () => {
    const result = workflowDraftToTree(nestedFixture())
    expect(result.ok).toBe(true)

    const outer = result.tree.next
    expect(outer.kind).toBe('branch')
    expect(outer.branches.map((item) => item.edgeKey)).toEqual(['e2', 'e3'])

    const inner = outer.branches[0].child
    expect(inner.kind).toBe('branch')
    expect(inner.gatewayKey).toBe('gw_2')
    expect(inner.branches.map((item) => item.edgeKey)).toEqual(['e4', 'e5'])
    expect(inner.branches[0].child).toEqual({ kind: 'step', nodeKey: 'user_task_x', next: null })
    // 内层的汇合点就是外层分支的出口（结束节点），内层不再重复渲染 next
    expect(inner.next).toBeNull()
    expect(outer.branches[1].child).toEqual({ kind: 'step', nodeKey: 'user_task_y', next: null })
    expect(pathOf(outer.next)).toEqual(['end'])
  })
})

describe('流程树编译：写回领域草稿', () => {
  const fixtures = [
    ['线性流程', linearFixture],
    ['两个条件', branchFixture],
    ['分支后公共审批', mergeFixture],
    ['嵌套条件', nestedFixture],
  ]

  it.each(fixtures)('%s：加载 → 构树 → 编译，拓扑与编码完全一致', (_name, make) => {
    const draft = make()
    const result = workflowDraftToTree(draft)
    expect(result.ok).toBe(true)

    const compiled = workflowTreeToDraft(result.tree, draft)
    expect(treeSignature(workflowDraftToTree(compiled).tree)).toBe(result.signature)
    expect(compiled.nodes.map((node) => node.nodeKey).toSorted()).toEqual(
      draft.nodes.map((node) => node.nodeKey).toSorted(),
    )
    // 连线与条件按编码比对：顺序无关，但拓扑、优先级、AST 必须逐项一致
    expect(edgeMapOf(compiled)).toEqual(edgeMapOf(draft))
  })

  it('编译保留节点配置与审批人规则，不会因为过一趟树就丢配置', () => {
    const draft = linearFixture()
    draft.nodes[1].config.approvalMode = 'all'
    draft.nodes[1].config.commentRequired = true
    draft.nodes[1].actorRules = [{ actorType: 'dept_manager', actorRef: 'initiator_dept' }]

    const compiled = workflowTreeToDraft(workflowDraftToTree(draft).tree, draft)
    const kept = compiled.nodes.find((node) => node.nodeKey === 'user_task_1')
    expect(kept.config.approvalMode).toBe('all')
    expect(kept.config.commentRequired).toBe(true)
    expect(kept.actorRules).toEqual([{ actorType: 'dept_manager', actorRef: 'initiator_dept' }])
  })

  it('从树里删掉节点后编译：节点与它的两条连线一起消失，前后自动接上', () => {
    const draft = linearFixture()
    const result = workflowDraftToTree(draft)
    // start → end：把中间那个审批节点摘掉
    result.tree.next = result.tree.next.next

    const compiled = workflowTreeToDraft(result.tree, draft)
    expect(compiled.nodes.map((node) => node.nodeKey)).toEqual(['start', 'end'])
    expect(compiled.edges).toHaveLength(1)
    expect(compiled.edges[0]).toMatchObject({ from: 'start', to: 'end', condition: null })
  })

  it('新插入的节点通过 extraNodes 提供定义后能编译进草稿', () => {
    const draft = linearFixture()
    const result = workflowDraftToTree(draft)
    const inserted = {
      ...N('user_task_9', 'user_task', '新增审批'),
      config: { ...defaultNodeConfig('user_task'), approvalMode: 'any' },
    }
    // 插到 start 与 user_task_1 之间
    result.tree.next = { kind: 'step', nodeKey: 'user_task_9', next: result.tree.next }

    const compiled = workflowTreeToDraft(result.tree, draft, [inserted])
    expect(compiled.nodes.map((node) => node.nodeKey)).toEqual(['start', 'user_task_9', 'user_task_1', 'end'])
    expect(compiled.nodes.find((node) => node.nodeKey === 'user_task_9').config.approvalMode).toBe('any')
    expect(
      compiled.edges
        .map((edge) => [edge.from, edge.to])
        .toSorted((a, b) => a[0].localeCompare(b[0])),
    ).toEqual([
      ['start', 'user_task_9'],
      ['user_task_1', 'end'],
      ['user_task_9', 'user_task_1'],
    ])
  })

  it('分支顺序变化会改写成 b_priority，默认出口始终最后', () => {
    const draft = mergeFixture()
    const result = workflowDraftToTree(draft)
    // 把第 2 条显式条件换到第 1 位
    const branches = result.tree.next.branches
    result.tree.next.branches = [branches[1], branches[0], branches[2]]

    const compiled = workflowTreeToDraft(result.tree, draft)
    const gatewayEdges = outgoingEdgesOf(compiled, 'gw_1')
    expect(gatewayEdges.map((edge) => edge.edgeKey)).toEqual(['e3', 'e2', 'e4'])
    expect(gatewayEdges.map((edge) => edge.priority)).toEqual([1, 2, 3])
    expect(gatewayEdges[2].condition).toBeNull()
  })
})

describe('流程树投影：必须保护的拓扑', () => {
  const unsupportedCases = [
    ['并行网关', parallelFixture, '并行分支'],
    ['缺少默认出口', missingDefaultFixture, '其他情况'],
    ['两条默认出口', duplicateDefaultFixture, '其他情况'],
    ['环（审批节点回连网关）', cycleFixture, '环形路径'],
    ['交叉连线', crossFixture, '交叉'],
  ]

  it.each(unsupportedCases)('%s：返回只读保护而不是压平后的树', (_name, make, keyword) => {
    const result = workflowDraftToTree(make())
    expect(result.ok).toBe(false)
    expect(result.reason).toContain(keyword)
    expect(result.tree).toBeUndefined()
  })

  it('服务节点同样受保护', () => {
    const draft = linearFixture()
    draft.nodes.splice(1, 0, N('service_1', 'service_task', '回调服务'))
    draft.edges = [
      E('e1', 'start', 'service_1'),
      E('e2', 'service_1', 'user_task_1'),
      E('e3', 'user_task_1', 'end'),
    ]
    const result = workflowDraftToTree(draft)
    expect(result.ok).toBe(false)
    expect(result.reason).toContain('服务节点')
  })

  it('存在不可达节点时不构树', () => {
    const draft = linearFixture()
    draft.nodes.push(N('user_task_9', 'user_task', '孤立节点'))
    const result = workflowDraftToTree(draft)
    expect(result.ok).toBe(false)
    expect(result.reason).toContain('孤立节点')
  })
})

describe('校验扩展（§5.2.6）', () => {
  it('结束节点有出线是错误，不再是警告', () => {
    const draft = linearFixture()
    draft.edges.push(E('e3', 'end', 'start'))
    const issues = validateWorkflowDomain(draft)
    expect(issues.some((item) => item.level === 'error' && item.message.includes('结束节点'))).toBe(true)
  })

  it('普通节点有多条出线是错误', () => {
    const draft = linearFixture()
    draft.edges.push(E('e3', 'user_task_1', 'start'))
    expect(messagesOf(draft)).toContain('节点「部门负责人审批」有多条出线，只有条件分支可以分支')
  })

  it('普通连线带条件是错误，不再是警告', () => {
    const draft = linearFixture()
    draft.edges[1] = { ...draft.edges[1], condition: AMOUNT_GT_1W }
    expect(messagesOf(draft)).toContain('「部门负责人审批」不是条件分支，其出线不应带条件')
  })

  it('条件分支缺少默认出口报错', () => {
    expect(messagesOf(missingDefaultFixture())).toContain(
      '条件分支「金额判断」缺少默认出口（需且仅需一条无条件连线）',
    )
  })

  it('条件分支有两条默认出口报错', () => {
    expect(messagesOf(duplicateDefaultFixture())).toContain('条件分支「金额判断」有 2 条默认出口，只允许一条')
  })

  it('条件分支只有一条出线报错', () => {
    const draft = branchFixture()
    draft.edges = draft.edges.filter((edge) => edge.edgeKey !== 'e4')
    expect(messagesOf(draft)).toContain('条件分支「金额判断」至少要有两条分支')
  })

  it('分支优先级重复时提示复核（判断顺序会退化成连线顺序）', () => {
    const draft = branchFixture()
    draft.edges = draft.edges.map((edge) => (edge.edgeKey === 'e4' ? { ...edge, priority: 1 } : edge))
    const warnings = validateWorkflowDomain(draft)
      .filter((item) => item.level === 'warn')
      .map((item) => item.message)
    expect(warnings).toContain('条件分支「金额判断」的分支优先级有重复，将按连线顺序确定判断顺序')
  })

  it('「其他情况」不在最后时给出可自愈的警告（保存时会重排）', () => {
    const draft = branchFixture()
    draft.edges = draft.edges.map((edge) => {
      if (edge.edgeKey === 'e3') return { ...edge, priority: 2 }
      if (edge.edgeKey === 'e4') return { ...edge, priority: 1 }
      return edge
    })
    const warnings = validateWorkflowDomain(draft)
      .filter((item) => item.level === 'warn')
      .map((item) => item.message)
    expect(warnings).toContain('条件分支「金额判断」的「其他情况」不在最后，保存时会按规范重排')
  })
})

describe('边优先级归一化', () => {
  it('按来源节点归一化成 1..n，跳号与全局序号都会被收敛', () => {
    const edges = [
      E('a1', 'gw', 'x', AMOUNT_GT_1W, 30),
      E('a2', 'gw', 'y', null, 10),
      E('b1', 'start', 'gw', null, 999),
    ]
    const normalized = normalizeEdgePriorities(edges)
    expect(normalized.map((edge) => [edge.edgeKey, edge.priority])).toEqual([
      ['a1', 2],
      ['a2', 1],
      ['b1', 1],
    ])
  })

  it('落库载荷写的是归一化后的优先级，不再是全局序号', () => {
    const draft = branchFixture()
    const payload = draftToSavePayload(draft)
    const gatewayEdges = payload.edges.filter((edge) => edge.b_from_node_key === 'gw_1')
    expect(gatewayEdges.map((edge) => [edge.b_id, edge.b_priority])).toEqual([
      ['e3', 10],
      ['e4', 20],
    ])
  })

  it('outgoingEdgesOf 按判断顺序返回出线', () => {
    const draft = mergeFixture()
    expect(outgoingEdgesOf(draft, 'gw_1').map((edge) => edge.edgeKey)).toEqual(['e2', 'e3', 'e4'])
  })
})