import { describe, expect, it, vi } from 'vitest';

import type { FieldDefinition } from '../../src/domain/types';
import { createOnlyOfficeBridge } from '../../src/onlyoffice/bridge';
import {
  disableTrackRevisionsCommand,
  insertTypedControlCommand,
  listContentControlsCommand,
  readControlTextCommand,
  setFormulaResultLockCommand,
  updateControlSpecCommand,
} from '../../src/onlyoffice/commands';
import type { TemplateBinding, TemplateControlSnapshot } from '../../src/domain/types';
import type { AscGlobal, OfficeContentControl } from '../../src/onlyoffice/types';
import { installOnlyOfficeGlobals, makeApiFixture } from '../fixtures/onlyoffice';

interface AscFixture {
  asc: AscGlobal;
  callCommands: Array<{ command: () => string; payload: unknown; scopeKey: string }>;
  closeCalls: Array<[string, string]>;
  listCommands: Array<{ command: () => string; payload: unknown; scopeKey: string }>;
  methodCalls: Array<[string, unknown[]]>;
}

interface AscFixtureOptions {
  autoCreateContentControl?: boolean;
  commandResults?: unknown[];
  methodResults?: unknown[];
}

const singleColor = { R: 23, G: 109, B: 92 };
type TextFieldDefinition = FieldDefinition & { controlType: 'text' };

function control(Tag: string, InternalId = `id-${Tag}`): OfficeContentControl {
  return { Alias: Tag, InternalId, Tag };
}

function textDefinition(overrides: Partial<TextFieldDefinition> = {}): FieldDefinition {
  return {
    controlType: 'text',
    fieldCode: 'result',
    alias: '结果',
    tag: 'eln.field.result',
    color: singleColor,
    placeholder: '请输入结果',
    defaultValue: '',
    defaultChecked: false,
    ...overrides,
  };
}

function typedDefinition(controlType: 'checkbox' | 'date' | 'dropdown' | 'multiline'): FieldDefinition {
  const base = {
    fieldCode: 'result',
    alias: '结果',
    tag: 'eln.field.result',
    color: singleColor,
  };

  if (controlType === 'dropdown') {
    return {
      ...base,
      controlType,
      placeholder: '请选择结果',
      options: [
        { display: '合格', value: 'pass' },
        { display: '不合格', value: 'fail' },
      ],
      selectedIndex: 1,
    };
  }

  return {
    ...base,
    controlType,
    placeholder: controlType === 'checkbox' ? '结果' : '请输入结果',
    defaultValue: controlType === 'date' ? '2026-08-11' : controlType === 'multiline' ? '第一行\n第二行' : '',
    defaultChecked: controlType === 'checkbox',
  };
}

function createAscFixture(options: AscFixtureOptions = {}): AscFixture {
  const methodResults = [...(options.methodResults ?? [])];
  const commandResults = [...(options.commandResults ?? [])];
  const methodCalls: Array<[string, unknown[]]> = [];
  const callCommands: AscFixture['callCommands'] = [];
  const listCommands: AscFixture['listCommands'] = [];
  const closeCalls: Array<[string, string]> = [];
  const scope: AscGlobal['scope'] = {};

  const asc: AscGlobal = {
    scope,
    plugin: {
      executeMethod(name, args, callback) {
        if (name === 'GetCurrentContentControl') {
          callback(null);
          return true;
        }
        methodCalls.push([name, args]);
        const result = methodResults.shift();
        if (name === 'AddContentControl' && result === undefined && options.autoCreateContentControl !== false) {
          const properties = args[1] as { Tag?: unknown } | undefined;
          const tag = typeof properties?.Tag === 'string' ? properties.Tag : '';
          callback({ InternalId: `id-${tag}`, Tag: tag });
          return true;
        }
        callback(result);
        return true;
      },
      callCommand(command, _isClose, _isCalc, callback) {
        const scopeKey = Object.keys(scope)[0] ?? '';
        if (command === listContentControlsCommand) {
          listCommands.push({ command, scopeKey, payload: scope[scopeKey] });
          callback({ ok: true, controls: methodResults.shift() });
          return true;
        }
        callCommands.push({ command, scopeKey, payload: scope[scopeKey] });
        callback(commandResults.length > 0 ? commandResults.shift() : { ok: true });
        return true;
      },
      executeCommand(command, data) {
        closeCalls.push([command, data]);
      },
      onThemeChangedBase: vi.fn(),
    },
  };

  return { asc, callCommands, closeCalls, listCommands, methodCalls };
}

describe('ONLYOFFICE bridge', () => {
  it('通过编辑器方法读取当前选中文本', async () => {
    const fixture = createAscFixture({ methodResults: [' 是否合格 '] });

    await expect(createOnlyOfficeBridge(fixture.asc).readSelectedText()).resolves.toBe(' 是否合格 ');
    expect(fixture.methodCalls).toEqual([['GetSelectedText', [{ Math: false, Numbering: false }]]]);
  });

  it('按结果主控件 Tag 锁定并恢复主控件及引用快照', async () => {
    const fixture = createAscFixture({
      commandResults: [
        { ok: true, snapshot: { primaryTag: 'eln.field.result', locks: [{ tag: 'eln.field.result', lock: 'unlocked' }] } },
        { ok: true, snapshot: { primaryTag: 'eln.field.result', locks: [{ tag: 'eln.field.result', lock: 'unlocked' }] } },
      ],
    });
    const bridge = createOnlyOfficeBridge(fixture.asc);
    const snapshot = await bridge.lockFormulaResult('eln.field.result');
    await bridge.restoreFormulaResultLocks(snapshot);

    expect(fixture.callCommands).toEqual([
      { command: setFormulaResultLockCommand, scopeKey: 'elnTemplateFormulaLocks', payload: { mode: 'lock', primaryTag: 'eln.field.result' } },
      { command: setFormulaResultLockCommand, scopeKey: 'elnTemplateFormulaLocks', payload: { mode: 'restore', snapshot } },
    ]);
  });
  it('原样读取插件运行 options', () => {
    const fixture = createAscFixture();
    const options = { context: true };
    fixture.asc.plugin.info = { options };

    expect(createOnlyOfficeBridge(fixture.asc).getRuntimeOptions()).toBe(options);
  });

  it('通过扫描 command 回读具体类型并清理列表 scope', async () => {
    const expected = [{ ...control('eln.field.result'), ControlType: 'date' as const }];
    const fixture = createAscFixture({ methodResults: [expected] });

    await expect(createOnlyOfficeBridge(fixture.asc).listControls()).resolves.toEqual(expected);
    expect(fixture.listCommands).toEqual([{ command: listContentControlsCommand, scopeKey: 'elnTemplateList', payload: {} }]);
    expect(fixture.asc.scope.elnTemplateList).toBeUndefined();
    expect(fixture.methodCalls).toHaveLength(0);
  });

  it('拒绝扫描 command 的非数组内容控件结果', async () => {
    const fixture = createAscFixture({ methodResults: [null] });

    await expect(createOnlyOfficeBridge(fixture.asc).listControls()).rejects.toThrow('编辑器未返回内容控件列表');
  });

  it('拒绝扫描 command 的同步异常', async () => {
    const fixture = createAscFixture();
    fixture.asc.plugin.callCommand = () => {
      throw new Error('method crashed');
    };

    await expect(createOnlyOfficeBridge(fixture.asc).listControls()).rejects.toThrow('method crashed');
  });
});

describe('ONLYOFFICE command bridge', () => {
  it('解除公式结果锁时使用 ONLYOFFICE 9.4 接受的 unlocked 值', () => {
    const apiFixture = makeApiFixture();
    const result = apiFixture.makeControl('text', 'eln.field.result');
    result.lock = 'contentLocked';
    const locks: string[] = [];
    result.SetLock = (value) => {
      locks.push(value);
      if (value !== 'unlocked') return false;
      result.lock = value;
      return true;
    };
    apiFixture.document.controls = [result];
    installOnlyOfficeGlobals(apiFixture.Api, {
      elnTemplateFormulaLocks: { mode: 'unlock', primaryTag: 'eln.field.result' },
    });

    expect(JSON.parse(setFormulaResultLockCommand())).toMatchObject({ ok: true });
    expect(locks).toEqual(['unlocked']);
  });

  it('关闭文档内部的修订跟踪状态', async () => {
    const fixture = createAscFixture({ commandResults: [{ ok: true }, { hasRevisionChanges: false, ok: true, trackRevisions: false }] });

    await expect(createOnlyOfficeBridge(fixture.asc).disableTrackRevisions()).resolves.toBeUndefined();
    expect(fixture.callCommands).toEqual([
      {
        command: disableTrackRevisionsCommand,
        scopeKey: 'elnTemplateReview',
        payload: {},
      },
      {
        command: expect.any(Function),
        scopeKey: 'elnTemplateReviewState',
        payload: {},
      },
    ]);
  });

  it('写命令回调缺失时仍通过独立只读命令确认修订已关闭', async () => {
    const fixture = createAscFixture({ commandResults: [undefined, { hasRevisionChanges: false, ok: true, trackRevisions: false }] });

    await expect(createOnlyOfficeBridge(fixture.asc).disableTrackRevisions()).resolves.toBeUndefined();
    expect(fixture.callCommands.map((item) => item.scopeKey)).toEqual(['elnTemplateReview', 'elnTemplateReviewState']);
  });

  it('独立回读仍为开启状态时禁止模板标注', async () => {
    const fixture = createAscFixture({ commandResults: [undefined, { hasRevisionChanges: false, ok: true, trackRevisions: true }] });

    await expect(createOnlyOfficeBridge(fixture.asc).disableTrackRevisions()).rejects.toThrow('修订跟踪仍处于开启状态');
  });

  it('独立回读仍有历史修订时禁止模板标注', async () => {
    const fixture = createAscFixture({ commandResults: [undefined, { hasRevisionChanges: true, ok: true, trackRevisions: false }] });

    await expect(createOnlyOfficeBridge(fixture.asc).disableTrackRevisions()).rejects.toThrow('历史修订仍未全部接受');
  });

  it.each([
    ['JSON 字符串', JSON.stringify({ ok: true })],
    ['对象', { ok: true }],
  ])('写入 scope，并接受%s命令结果', async (_label, commandResult) => {
    const tag = 'eln.field.result';
    const fixture = createAscFixture({ methodResults: [[], [control(tag)]], commandResults: [commandResult] });

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(typedDefinition('checkbox'))).resolves.toEqual([control(tag)]);

    expect(fixture.callCommands).toHaveLength(1);
    expect(fixture.callCommands[0]).toMatchObject({
      command: insertTypedControlCommand,
      scopeKey: 'elnTemplateInsert',
    });
    expect(fixture.asc.scope.elnTemplateInsert).toBeUndefined();
  });

  it.each([
    [{ ok: false, error: '业务失败' }, '业务失败'],
    [{ ok: false }, '编辑器命令执行失败'],
    [{ ok: false, error: 500 }, '编辑器命令执行失败'],
  ])('归一化命令失败 %#', async (commandResult, message) => {
    const fixture = createAscFixture({ methodResults: [[]], commandResults: [commandResult] });

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(typedDefinition('checkbox'))).rejects.toThrow(message);
    expect(fixture.asc.scope.elnTemplateInsert).toBeUndefined();
  });

  it.each([
    ['非法 JSON', 'not-json'],
    ['null', null],
    ['数组', []],
    ['数字', 1],
    ['缺少 ok 的对象', { error: '业务失败' }],
    ['ok 非布尔值', { ok: 'false', error: '业务失败' }],
  ])('拒绝%s命令返回值', async (_label, commandResult) => {
    const fixture = createAscFixture({ methodResults: [[]], commandResults: [commandResult] });

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(typedDefinition('checkbox'))).rejects.toThrow('编辑器命令返回无效结果');
    expect(fixture.asc.scope.elnTemplateInsert).toBeUndefined();
  });

  it('归一化 callCommand 同步异常并清理 scope', async () => {
    const fixture = createAscFixture({ methodResults: [[]] });
    fixture.asc.plugin.callCommand = () => {
      throw new Error('command crashed');
    };

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(typedDefinition('checkbox'))).rejects.toThrow('command crashed');
    expect(fixture.asc.scope.elnTemplateInsert).toBeUndefined();
  });
});

describe('字段插入', () => {
  it('插入前拒绝已存在的 Tag，且不执行插入', async () => {
    const fixture = createAscFixture({ methodResults: [[control('eln.field.result')]] });

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(textDefinition())).rejects.toThrow('字段 ID 已存在');
    expect(fixture.methodCalls).toHaveLength(0);
    expect(fixture.listCommands).toHaveLength(1);
    expect(fixture.callCommands).toHaveLength(0);
  });

  it('插入前拒绝现有 ELN 控件的同名 Alias，且忽略首尾空格', async () => {
    const fixture = createAscFixture({
      methodResults: [[{ Alias: ' 结果 ', InternalId: 'existing-1', Tag: 'eln.field.other_result' }]],
    });

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(textDefinition())).rejects.toThrow('字段名称已存在');
    expect(fixture.methodCalls).toHaveLength(0);
    expect(fixture.listCommands).toHaveLength(1);
    expect(fixture.callCommands).toHaveLength(0);
  });

  it('非 ELN 内容控件的同名 Alias 不参与字段名称校验', async () => {
    const definition = textDefinition();
    const after = [{ Alias: '结果', InternalId: 'custom-1', Tag: 'custom.control' }, control(definition.tag)];
    const fixture = createAscFixture({
      methodResults: [[{ Alias: '结果', InternalId: 'custom-1', Tag: 'custom.control' }], undefined, after],
    });

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(definition)).resolves.toBe(after);
  });

  it('文本字段通过原生接口插入并携带完整控件属性', async () => {
    const definition = textDefinition();
    const after = [control(definition.tag)];
    const fixture = createAscFixture({ methodResults: [[], undefined, after] });

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(definition)).resolves.toBe(after);
    expect(fixture.methodCalls).toEqual([
      [
        'AddContentControl',
        [
          2,
          {
            Alias: definition.alias,
            Appearance: 1,
            Color: definition.color,
            Lock: 3,
            PlaceHolderText: definition.placeholder,
            Tag: definition.tag,
          },
        ],
      ],
    ]);
    expect(fixture.callCommands).toEqual([]);
    expect(fixture.listCommands).toHaveLength(2);
  });

  it('单行文本使用编辑器保存的光标位置插入', async () => {
    const definition = textDefinition();
    const after = [control(definition.tag)];
    const fixture = createAscFixture({
      commandResults: [{ error: 'API command 无法定位当前光标', ok: false }],
      methodResults: [[], undefined, after],
    });

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(definition)).resolves.toBe(after);
    expect(fixture.methodCalls).toEqual([
      [
        'AddContentControl',
        [
          2,
          expect.objectContaining({
            Alias: definition.alias,
            PlaceHolderText: definition.placeholder,
            Tag: definition.tag,
          }),
        ],
      ],
    ]);
    expect(fixture.callCommands).toEqual([]);
  });

  it('文本默认值随文本控件一并插入', async () => {
    const definition = textDefinition({ defaultValue: 'S-001' });
    const fixture = createAscFixture({
      methodResults: [
        [],
        undefined,
        [control(definition.tag)],
        undefined,
        undefined,
        { InternalId: `id-${definition.tag}`, Tag: definition.tag, content: 'S-001' },
        [control(definition.tag)],
      ],
    });

    await createOnlyOfficeBridge(fixture.asc).insertField(definition);

    expect(fixture.methodCalls).toEqual([
      ['AddContentControl', [2, expect.objectContaining({ Tag: definition.tag })]],
      ['GetAllContentControls', []],
      ['MoveCursorToContentControl', [`id-${definition.tag}`, true]],
      ['InputText', ['S-001']],
      ['GetCurrentContentControlPr', ['text']],
    ]);
    expect(fixture.callCommands).toEqual([]);
  });

  it('原生文本插入失败时报告光标位置错误且不执行后续命令', async () => {
    const definition = textDefinition();
    const fixture = createAscFixture({ autoCreateContentControl: false, methodResults: [[], undefined] });

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(definition)).rejects.toThrow('编辑器未能在光标位置插入文本控件');
    expect(fixture.methodCalls).toEqual([['AddContentControl', [2, expect.objectContaining({ Tag: definition.tag })]]]);
    expect(fixture.callCommands).toHaveLength(0);
  });

  it.each([
    [
      'dropdown' as const,
      {
        controlType: 'dropdown',
        tag: 'eln.field.result',
        alias: '结果',
        placeholder: '请选择结果',
        defaultValue: '',
        defaultChecked: false,
        options: [
          { display: '合格', value: 'pass' },
          { display: '不合格', value: 'fail' },
        ],
        selectedIndex: 1,
        color: singleColor,
      },
    ],
    [
      'checkbox' as const,
      {
        controlType: 'checkbox',
        tag: 'eln.field.result',
        alias: '结果',
        placeholder: '结果',
        defaultValue: '',
        defaultChecked: true,
        options: [],
        selectedIndex: -1,
        color: singleColor,
      },
    ],
    [
      'date' as const,
      {
        controlType: 'date',
        tag: 'eln.field.result',
        alias: '结果',
        placeholder: '请输入结果',
        defaultValue: '2026-08-11',
        defaultChecked: false,
        options: [],
        selectedIndex: -1,
        color: singleColor,
      },
    ],
    [
      'multiline' as const,
      {
        controlType: 'multiline',
        tag: 'eln.field.result',
        alias: '结果',
        placeholder: '请输入结果',
        defaultValue: '第一行\n第二行',
        defaultChecked: false,
        options: [],
        selectedIndex: -1,
        color: singleColor,
      },
    ],
  ])('%s 字段使用 typed command 的完整兼容 payload', async (controlType, expectedPayload) => {
    const definition = typedDefinition(controlType);
    const fixture = createAscFixture({ methodResults: [[], [control(definition.tag)]] });

    await createOnlyOfficeBridge(fixture.asc).insertField(definition);

    expect(fixture.callCommands).toEqual([
      {
        command: insertTypedControlCommand,
        scopeKey: 'elnTemplateInsert',
        payload: expect.objectContaining(expectedPayload),
      },
    ]);
  });

  it.each([
    ['没有增加', []],
    ['异常增加两个', [control('eln.field.result', 'first'), control('eln.field.result', 'second')]],
  ])('插入后 Tag 计数%s时失败', async (_label, after) => {
    const definition = typedDefinition('checkbox');
    const fixture = createAscFixture({ methodResults: [[], after] });

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(definition)).rejects.toThrow('插入后 Tag 计数未增加');
  });

  it.each([
    ['text', textDefinition(), [[], undefined, null]],
    ['typed', typedDefinition('checkbox'), [[], null]],
  ])('%s 字段插入后枚举结果非数组时使用插入后错误', async (_label, definition, methodResults) => {
    const fixture = createAscFixture({ methodResults });

    await expect(createOnlyOfficeBridge(fixture.asc).insertField(definition)).rejects.toThrow('插入后无法读取内容控件列表');
  });
});

describe('定位、关闭与生命周期', () => {
  it('删除拒绝空的内部 ID', async () => {
    const fixture = createAscFixture();

    await expect(createOnlyOfficeBridge(fixture.asc).deleteControl('')).rejects.toThrow('该内容控件没有可用的内部 ID');
    expect(fixture.methodCalls).toHaveLength(0);
  });

  it('解除目标不存在时不调用移除方法', async () => {
    const fixture = createAscFixture({ methodResults: [[control('eln.field.other', 'other-id')]] });

    await expect(createOnlyOfficeBridge(fixture.asc).deleteControl('stale-id')).rejects.toThrow('删除目标已不存在，请刷新字段列表');
    expect(fixture.methodCalls).toHaveLength(0);
    expect(fixture.listCommands).toHaveLength(1);
  });

  it.each([
    ['移除外壳失败', [[control('eln.field.result', 'control-1')], false], '编辑器未能移除字段控件'],
    ['解除后仍存在', [[control('eln.field.result', 'control-1')], true, [control('eln.field.result', 'control-1')]], '解除后字段仍然存在'],
  ])('%s时拒绝解除', async (_label, methodResults, message) => {
    const fixture = createAscFixture({ methodResults });

    await expect(createOnlyOfficeBridge(fixture.asc).deleteControl('control-1')).rejects.toThrow(message);
  });

  it('只移除内容控件外壳、保留内容并返回解除后的列表', async () => {
    const remaining = [control('eln.field.other', 'other-id')];
    const fixture = createAscFixture({ methodResults: [[control('eln.field.result', 'control-1'), ...remaining], undefined, remaining] });

    await expect(createOnlyOfficeBridge(fixture.asc).deleteControl('control-1')).resolves.toBe(remaining);
    expect(fixture.methodCalls).toEqual([['RemoveContentControl', ['control-1']]]);
    expect(fixture.listCommands).toHaveLength(2);
  });

  it('拒绝空的内部 ID', async () => {
    const fixture = createAscFixture();

    await expect(createOnlyOfficeBridge(fixture.asc).selectControl('')).rejects.toThrow('该内容控件没有可用的内部 ID');
    expect(fixture.methodCalls).toHaveLength(0);
  });

  it('目标已不存在时不调用定位方法', async () => {
    const fixture = createAscFixture({ methodResults: [[control('eln.field.other', 'other-id')]] });

    await expect(createOnlyOfficeBridge(fixture.asc).selectControl('stale-id')).rejects.toThrow('定位目标已不存在，请刷新字段列表');
    expect(fixture.methodCalls).toHaveLength(0);
    expect(fixture.listCommands).toHaveLength(1);
  });

  it('编辑器明确返回 false 时报告定位失败', async () => {
    const fixture = createAscFixture({ methodResults: [[control('eln.field.result', 'control-1')], false] });

    await expect(createOnlyOfficeBridge(fixture.asc).selectControl('control-1')).rejects.toThrow('编辑器未能定位字段');
    expect(fixture.methodCalls).toEqual([['SelectContentControl', ['control-1']]]);
    expect(fixture.listCommands).toHaveLength(1);
  });

  it.each([undefined, true])('通过内部 ID 定位内容控件并兼容返回 %s', async (result) => {
    const fixture = createAscFixture({ methodResults: [[control('eln.field.result', 'control-1')], result] });

    await expect(createOnlyOfficeBridge(fixture.asc).selectControl('control-1')).resolves.toBeUndefined();
    expect(fixture.methodCalls).toEqual([['SelectContentControl', ['control-1']]]);
    expect(fixture.listCommands).toHaveLength(1);
  });

  it('关闭插件窗口', () => {
    const fixture = createAscFixture();

    createOnlyOfficeBridge(fixture.asc).close();

    expect(fixture.closeCalls).toEqual([['close', '']]);
  });

  it('绑定 init、button 和主题回调，并在 cleanup 时恢复旧引用', () => {
    const events: string[] = [];
    const fixture = createAscFixture();
    const oldInit = vi.fn();
    const oldButton = vi.fn();
    const oldTheme = vi.fn();
    fixture.asc.plugin.init = oldInit;
    fixture.asc.plugin.button = oldButton;
    fixture.asc.plugin.onThemeChanged = oldTheme;
    fixture.asc.plugin.onThemeChangedBase = vi.fn(() => events.push('base'));
    const cleanup = createOnlyOfficeBridge(fixture.asc).bindLifecycle({
      onReady: () => events.push('ready'),
      onThemeChanged: () => events.push('theme'),
    });

    fixture.asc.plugin.init?.();
    fixture.asc.plugin.button?.(0);
    fixture.asc.plugin.button?.(-1);
    fixture.asc.plugin.onThemeChanged?.({ type: 'dark' });

    expect(events).toEqual(['ready', 'base', 'theme']);
    expect(fixture.closeCalls).toEqual([['close', '']]);
    cleanup();
    expect(fixture.asc.plugin.init).toBe(oldInit);
    expect(fixture.asc.plugin.button).toBe(oldButton);
    expect(fixture.asc.plugin.onThemeChanged).toBe(oldTheme);
  });

  it('旧实例 cleanup 不覆盖较新实例的生命周期函数', () => {
    const fixture = createAscFixture();
    const firstCleanup = createOnlyOfficeBridge(fixture.asc).bindLifecycle({ onReady: vi.fn(), onThemeChanged: vi.fn() });
    createOnlyOfficeBridge(fixture.asc).bindLifecycle({ onReady: vi.fn(), onThemeChanged: vi.fn() });
    const secondLifecycle = {
      init: fixture.asc.plugin.init,
      button: fixture.asc.plugin.button,
      onThemeChanged: fixture.asc.plugin.onThemeChanged,
    };

    firstCleanup();

    expect(fixture.asc.plugin.init).toBe(secondLifecycle.init);
    expect(fixture.asc.plugin.button).toBe(secondLifecycle.button);
    expect(fixture.asc.plugin.onThemeChanged).toBe(secondLifecycle.onThemeChanged);
  });

  it('交错 cleanup 后恢复绑定前引用且已释放实例不再响应', () => {
    const fixture = createAscFixture();
    const oldInit = vi.fn();
    const oldButton = vi.fn();
    const oldTheme = vi.fn();
    const firstReady = vi.fn();
    const firstTheme = vi.fn();
    const secondReady = vi.fn();
    const secondTheme = vi.fn();
    fixture.asc.plugin.init = oldInit;
    fixture.asc.plugin.button = oldButton;
    fixture.asc.plugin.onThemeChanged = oldTheme;
    const firstCleanup = createOnlyOfficeBridge(fixture.asc).bindLifecycle({
      onReady: firstReady,
      onThemeChanged: firstTheme,
    });
    const secondCleanup = createOnlyOfficeBridge(fixture.asc).bindLifecycle({
      onReady: secondReady,
      onThemeChanged: secondTheme,
    });

    fixture.asc.plugin.init?.();
    fixture.asc.plugin.onThemeChanged?.({ type: 'contrast' });
    expect(firstReady).not.toHaveBeenCalled();
    expect(firstTheme).not.toHaveBeenCalled();
    expect(secondReady).toHaveBeenCalledTimes(1);
    expect(secondTheme).toHaveBeenCalledTimes(1);

    firstCleanup();
    fixture.asc.plugin.init?.();
    fixture.asc.plugin.onThemeChanged?.({ type: 'dark' });

    expect(firstReady).not.toHaveBeenCalled();
    expect(firstTheme).not.toHaveBeenCalled();
    expect(secondReady).toHaveBeenCalledTimes(2);
    expect(secondTheme).toHaveBeenCalledTimes(2);

    secondCleanup();
    expect(fixture.asc.plugin.init).toBe(oldInit);
    expect(fixture.asc.plugin.button).toBe(oldButton);
    expect(fixture.asc.plugin.onThemeChanged).toBe(oldTheme);

    fixture.asc.plugin.init?.();
    fixture.asc.plugin.button?.(-1);
    fixture.asc.plugin.onThemeChanged?.({ type: 'light' });
    expect(firstReady).not.toHaveBeenCalled();
    expect(firstTheme).not.toHaveBeenCalled();
    expect(secondReady).toHaveBeenCalledTimes(2);
    expect(secondTheme).toHaveBeenCalledTimes(2);
    expect(oldInit).toHaveBeenCalledTimes(1);
    expect(oldButton).toHaveBeenCalledWith(-1);
    expect(oldTheme).toHaveBeenCalledWith({ type: 'light' });
  });
});

describe('后端绑定 bridge', () => {
  const primary: TemplateBinding = {
    controlAlias: '结果',
    controlConfig: { placeholder: '请输入结果' },
    controlRole: 'PRIMARY',
    controlTag: 'eln.field.result',
    controlType: 'TEXT',
    fieldCode: 'result',
    fieldId: 'field',
    fieldVersionId: 'version',
    id: 'primary',
    primaryBindingId: null,
    status: 'PENDING',
    templateId: 'template',
    version: 0,
  };

  it('光标位于已有内容控件时拒绝嵌套插入', async () => {
    const fixture = createAscFixture({ commandResults: [{ ok: true }] });
    fixture.asc.plugin.executeMethod = (name, args, callback) => {
      fixture.methodCalls.push([name, args]);
      callback(name === 'GetCurrentContentControl' ? 'outer-control' : { InternalId: 'created' });
      return true;
    };

    await expect(createOnlyOfficeBridge(fixture.asc).insertBinding(primary)).rejects.toThrow('请将光标移到已有字段控件外再插入');

    expect(fixture.methodCalls).toEqual([['GetCurrentContentControl', []]]);
  });

  it('历史空占位配置创建主控件时回退为控件别名，不重复按 Tag 更新', async () => {
    const fixture = createAscFixture();

    await createOnlyOfficeBridge(fixture.asc).insertBinding({ ...primary, controlConfig: { placeholder: '' } });

    expect(fixture.methodCalls).toEqual([
      ['AddContentControl', [2, expect.objectContaining({ Alias: '结果', Lock: 3, PlaceHolderText: '结果', Tag: primary.controlTag })]],
    ]);
    expect(fixture.callCommands).toEqual([]);
  });

  it('文本引用读取主字段当前文本，使用后端 eln.ref Tag 直接插入只读控件', async () => {
    const reference = { ...primary, controlRole: 'REFERENCE', controlTag: 'eln.ref.result.abc', id: 'reference', primaryBindingId: 'primary' };
    const fixture = createAscFixture({
      commandResults: [{ ok: true, text: '12.3' }],
      methodResults: [
        undefined,
        [control(reference.controlTag)],
        undefined,
        undefined,
        { InternalId: `id-${reference.controlTag}`, Tag: reference.controlTag, content: '12.3' },
      ],
    });

    await createOnlyOfficeBridge(fixture.asc).insertReference(reference, primary.controlTag);

    expect(fixture.methodCalls).toEqual([
      ['AddContentControl', [2, expect.objectContaining({ Alias: '结果', Lock: 0, Tag: reference.controlTag })]],
      ['GetAllContentControls', []],
      ['MoveCursorToContentControl', [`id-${reference.controlTag}`, true]],
      ['InputText', ['12.3']],
      ['GetCurrentContentControlPr', ['text']],
    ]);
    expect(fixture.callCommands).toEqual([{ command: readControlTextCommand, scopeKey: 'elnTemplateReadText', payload: { tag: primary.controlTag } }]);
  });

  it('中止后读到引用文本不再创建内容控件', async () => {
    const reference = { ...primary, controlRole: 'REFERENCE', controlTag: 'eln.ref.result.abc', id: 'reference', primaryBindingId: 'primary' };
    const fixture = createAscFixture();
    let completeRead!: (result: unknown) => void;
    fixture.asc.plugin.callCommand = (command, _isClose, _isCalc, callback) => {
      expect(command).toBe(readControlTextCommand);
      completeRead = callback;
      return true;
    };
    const controller = new AbortController();
    const operation = createOnlyOfficeBridge(fixture.asc).insertReference(reference, primary.controlTag, controller.signal);

    controller.abort();
    completeRead({ ok: true, text: '12.3' });
    await operation;

    expect(fixture.methodCalls).not.toContainEqual(expect.arrayContaining(['AddContentControl']));
  });

  it('按后端检查结果删除旧控件并更新主字段与全部引用', async () => {
    const reference = {
      ...primary,
      controlRole: 'REFERENCE',
      controlTag: 'eln.ref.result.abc',
      id: 'reference',
      primaryBindingId: 'primary',
      status: 'ACTIVE',
    };
    const fixture = createAscFixture({
      commandResults: [{ ok: true, updated: 1 }],
      methodResults: [[control(primary.controlTag, 'primary-control'), control(reference.controlTag, 'reference-control')], true],
    });
    const desired: TemplateControlSnapshot[] = [
      {
        bindingId: 'reference',
        controlAlias: '结果',
        controlConfig: {},
        controlRole: 'PRIMARY',
        controlTag: 'eln.field.result',
        controlType: 'TEXT',
        fieldVersionId: 'version',
        primaryBindingId: null,
      },
    ];

    await createOnlyOfficeBridge(fixture.asc).applyControlPlan([{ ...primary, status: 'ACTIVE' }, reference], desired);

    expect(fixture.methodCalls).not.toContainEqual(['RemoveContentControl', ['primary-control']]);
    expect(fixture.callCommands).toContainEqual(
      expect.objectContaining({
        command: updateControlSpecCommand,
        payload: { removals: [primary.controlTag], updates: [expect.objectContaining({ currentTag: reference.controlTag, tag: 'eln.field.result' })] },
      }),
    );
  });

  it('一次计划包含多个删除时在修改文档前拒绝执行', async () => {
    const another = { ...primary, controlTag: 'eln.field.conclusion', fieldCode: 'conclusion', id: 'another', status: 'ACTIVE' };
    const fixture = createAscFixture({
      methodResults: [[control(primary.controlTag, 'primary-control'), control(another.controlTag, 'another-control')]],
    });

    await expect(createOnlyOfficeBridge(fixture.asc).applyControlPlan([{ ...primary, status: 'ACTIVE' }, another], [])).rejects.toThrow(
      '当前阶段不支持一次删除多个控件',
    );

    expect(fixture.methodCalls).not.toContainEqual(expect.arrayContaining(['RemoveContentControl']));
    expect(fixture.callCommands).not.toContainEqual(expect.objectContaining({ command: updateControlSpecCommand }));
  });

  it('字段版本改变控件类型时在发送更新命令前明确拒绝', async () => {
    const fixture = createAscFixture({
      methodResults: [[{ ...control(primary.controlTag, 'primary-control'), ControlType: 'text' }]],
    });
    const desired: TemplateControlSnapshot[] = [
      {
        bindingId: primary.id,
        controlAlias: '结果',
        controlConfig: { dateFormat: 'yyyy-MM-dd' },
        controlRole: 'PRIMARY',
        controlTag: primary.controlTag,
        controlType: 'DATE',
        fieldVersionId: 'version-2',
        primaryBindingId: null,
      },
    ];

    await expect(createOnlyOfficeBridge(fixture.asc).applyControlPlan([{ ...primary, status: 'ACTIVE' }], desired)).rejects.toThrow(
      '当前阶段不支持修改已有控件类型',
    );

    expect(fixture.callCommands).not.toContainEqual(expect.objectContaining({ command: updateControlSpecCommand }));
  });

  it('目标 placeholder 为空但文档旧值非空时在发送更新命令前拒绝', async () => {
    const fixture = createAscFixture({
      methodResults: [
        [
          {
            Alias: '结果',
            ControlConfig: { placeholder: '原提示' },
            ControlRole: 'PRIMARY',
            ControlType: 'text',
            InternalId: 'primary-control',
            Lock: 'unlocked',
            Tag: primary.controlTag,
          },
        ],
      ],
    });
    const desired: TemplateControlSnapshot[] = [
      {
        bindingId: primary.id,
        controlAlias: '结果',
        controlConfig: { placeholder: '' },
        controlRole: 'PRIMARY',
        controlTag: primary.controlTag,
        controlType: 'TEXT',
        fieldVersionId: 'version-2',
        primaryBindingId: null,
      },
    ];

    await expect(createOnlyOfficeBridge(fixture.asc).applyControlPlan([{ ...primary, status: 'ACTIVE' }], desired)).rejects.toThrow(
      '当前编辑器不支持清空已有占位文本',
    );

    expect(fixture.callCommands).not.toContainEqual(expect.objectContaining({ command: updateControlSpecCommand }));
  });

  it('目标和文档 placeholder 均为空时允许发送更新命令', async () => {
    const emptyPlaceholder = { ...primary, controlConfig: { placeholder: '' }, status: 'ACTIVE' };
    const fixture = createAscFixture({
      commandResults: [{ ok: true, updated: 1 }],
      methodResults: [
        [
          {
            Alias: '结果',
            ControlConfig: { placeholder: '' },
            ControlRole: 'PRIMARY',
            ControlType: 'text',
            InternalId: 'primary-control',
            Lock: 'unlocked',
            Tag: primary.controlTag,
          },
        ],
      ],
    });
    const desired: TemplateControlSnapshot[] = [
      {
        bindingId: primary.id,
        controlAlias: '新结果',
        controlConfig: { placeholder: '' },
        controlRole: 'PRIMARY',
        controlTag: primary.controlTag,
        controlType: 'TEXT',
        fieldVersionId: 'version-2',
        primaryBindingId: null,
      },
    ];

    await expect(createOnlyOfficeBridge(fixture.asc).applyControlPlan([emptyPlaceholder], desired)).resolves.toBeUndefined();
    expect(fixture.callCommands).toContainEqual(expect.objectContaining({ command: updateControlSpecCommand }));
  });

  it('同 Tag 版本升级已写入 DOCX 时属性匹配即跳过重复 setter', async () => {
    const fixture = createAscFixture({
      methodResults: [
        [
          {
            Alias: '结果',
            ControlConfig: { placeholder: '请输入结果' },
            ControlRole: 'PRIMARY',
            ControlType: 'text',
            InternalId: 'primary-control',
            Lock: 'unlocked',
            Tag: primary.controlTag,
          },
        ],
      ],
    });
    const desired: TemplateControlSnapshot[] = [
      {
        bindingId: primary.id,
        controlAlias: '结果',
        controlConfig: { placeholder: '请输入结果' },
        controlRole: 'PRIMARY',
        controlTag: primary.controlTag,
        controlType: 'TEXT',
        fieldVersionId: 'version-2',
        primaryBindingId: null,
      },
    ];

    await expect(createOnlyOfficeBridge(fixture.asc).applyControlPlan([{ ...primary, status: 'ACTIVE' }], desired)).resolves.toBeUndefined();

    expect(fixture.callCommands).not.toContainEqual(expect.objectContaining({ command: updateControlSpecCommand }));
  });

  it('CHECKBOX 升级幂等重试忽略目标版本 defaultChecked 与文档当前勾选态差异', async () => {
    const checkbox = {
      ...primary,
      controlConfig: { defaultChecked: false },
      controlType: 'CHECKBOX',
      status: 'ACTIVE',
    };
    const fixture = createAscFixture({
      methodResults: [
        [
          {
            Alias: '结果',
            ControlConfig: { defaultChecked: false },
            ControlRole: 'PRIMARY',
            ControlType: 'checkbox',
            InternalId: 'checkbox-control',
            Lock: 'unlocked',
            Tag: checkbox.controlTag,
          },
        ],
      ],
    });
    const desired: TemplateControlSnapshot[] = [
      {
        bindingId: checkbox.id,
        controlAlias: '结果',
        controlConfig: { defaultChecked: true },
        controlRole: 'PRIMARY',
        controlTag: checkbox.controlTag,
        controlType: 'CHECKBOX',
        fieldVersionId: 'version-2',
        primaryBindingId: null,
      },
    ];

    await expect(createOnlyOfficeBridge(fixture.asc).applyControlPlan([checkbox], desired)).resolves.toBeUndefined();

    expect(fixture.callCommands).not.toContainEqual(expect.objectContaining({ command: updateControlSpecCommand }));
  });

  it('引用提升已写入 DOCX 时识别唯一目标控件并跳过重复改写和删除', async () => {
    const reference = {
      ...primary,
      controlRole: 'REFERENCE',
      controlTag: 'eln.ref.result.abc',
      id: 'reference',
      primaryBindingId: primary.id,
      status: 'ACTIVE',
    };
    const fixture = createAscFixture({
      methodResults: [
        [
          {
            Alias: '结果',
            ControlConfig: { placeholder: '请输入结果' },
            ControlRole: 'PRIMARY',
            ControlType: 'text',
            InternalId: 'promoted-control',
            Lock: 'unlocked',
            Tag: primary.controlTag,
          },
        ],
      ],
    });
    const desired: TemplateControlSnapshot[] = [
      {
        bindingId: reference.id,
        controlAlias: '结果',
        controlConfig: { placeholder: '请输入结果' },
        controlRole: 'PRIMARY',
        controlTag: primary.controlTag,
        controlType: 'TEXT',
        fieldVersionId: 'version',
        primaryBindingId: null,
      },
    ];

    await expect(createOnlyOfficeBridge(fixture.asc).applyControlPlan([{ ...primary, status: 'ACTIVE' }, reference], desired)).resolves.toBeUndefined();

    expect(fixture.callCommands).not.toContainEqual(expect.objectContaining({ command: updateControlSpecCommand }));
    expect(fixture.methodCalls).not.toContainEqual(expect.arrayContaining(['RemoveContentControl']));
  });

  it('删除已写入 DOCX 时允许空计划重试且不再发送删除命令', async () => {
    const fixture = createAscFixture({ methodResults: [[]] });

    await expect(createOnlyOfficeBridge(fixture.asc).applyControlPlan([{ ...primary, status: 'ACTIVE' }], [])).resolves.toBeUndefined();

    expect(fixture.callCommands).not.toContainEqual(expect.objectContaining({ command: updateControlSpecCommand }));
    expect(fixture.methodCalls).not.toContainEqual(expect.arrayContaining(['RemoveContentControl']));
  });

  it('中止后首次枚举返回时不删除或更新控件', async () => {
    const fixture = createAscFixture();
    let completeList!: (result: unknown) => void;
    fixture.asc.plugin.callCommand = (command, _isClose, _isCalc, callback) => {
      expect(command).toBe(listContentControlsCommand);
      completeList = callback;
      return true;
    };
    const controller = new AbortController();
    const operation = createOnlyOfficeBridge(fixture.asc).applyControlPlan([{ ...primary, status: 'ACTIVE' }], [], controller.signal);

    controller.abort();
    completeList({ ok: true, controls: [control(primary.controlTag, 'primary-control')] });
    await operation;

    expect(fixture.methodCalls).not.toContainEqual(['RemoveContentControl', ['primary-control']]);
    expect(fixture.callCommands).not.toContainEqual(expect.objectContaining({ command: updateControlSpecCommand }));
  });

  it('中止后内部枚举返回时不调用编辑器定位控件', async () => {
    const fixture = createAscFixture();
    let completeList!: (result: unknown) => void;
    fixture.asc.plugin.callCommand = (command, _isClose, _isCalc, callback) => {
      expect(command).toBe(listContentControlsCommand);
      completeList = callback;
      return true;
    };
    const controller = new AbortController();
    const operation = createOnlyOfficeBridge(fixture.asc).selectControl('control-1', controller.signal);

    controller.abort();
    completeList({ ok: true, controls: [control(primary.controlTag, 'control-1')] });
    await operation;

    expect(fixture.methodCalls).not.toContainEqual(['SelectContentControl', ['control-1']]);
  });

  it('中止后控件插入返回时不再继续更新属性', async () => {
    const reference = { ...primary, controlRole: 'REFERENCE', controlTag: 'eln.ref.result.abc', id: 'reference', primaryBindingId: 'primary' };
    const fixture = createAscFixture();
    let completeInsert!: (result: unknown) => void;
    fixture.asc.plugin.executeMethod = (name, args, callback) => {
      if (name === 'GetCurrentContentControl') {
        callback(null);
        return true;
      }
      expect(name).toBe('AddContentControl');
      fixture.methodCalls.push([name, args]);
      completeInsert = callback;
      return true;
    };
    const controller = new AbortController();
    const operation = createOnlyOfficeBridge(fixture.asc).insertBinding(reference, controller.signal);

    await vi.waitFor(() => expect(completeInsert).toBeTypeOf('function'));
    controller.abort();
    completeInsert({ InternalId: 'reference-control', Tag: reference.controlTag });
    await operation;

    expect(fixture.methodCalls).toEqual([['AddContentControl', [2, expect.objectContaining({ Tag: reference.controlTag })]]]);
    expect(fixture.callCommands).toEqual([]);
  });

  it('确认快照使用文档实际属性，只从绑定关联不可写入 DOCX 的 ID', () => {
    const bridge = createOnlyOfficeBridge(createAscFixture().asc);
    const controls: OfficeContentControl[] = [
      {
        Alias: '结果',
        ControlConfig: { placeholder: '请输入结果' },
        ControlRole: 'PRIMARY',
        ControlType: 'text',
        InternalId: 'id',
        Lock: 'unlocked',
        Tag: primary.controlTag,
      },
    ];
    expect(bridge.snapshotControls([primary], controls)).toEqual([
      {
        bindingId: 'primary',
        controlAlias: '结果',
        controlConfig: { placeholder: '请输入结果' },
        controlRole: 'PRIMARY',
        controlTag: primary.controlTag,
        controlType: 'TEXT',
        fieldVersionId: 'version',
        primaryBindingId: null,
      },
    ]);
  });

  it('确认快照保留步骤归属和重复组身份', () => {
    const bridge = createOnlyOfficeBridge(createAscFixture().asc);
    const repeat = {
      ...primary,
      controlRole: 'REPEAT',
      controlTag: 'eln.repeat.results.prototype.result',
      primaryBindingId: null,
      repeatGroupCode: 'results',
      repeatPrototypeRowId: 'prototype',
      stepId: 'step-test',
    };
    const controls: OfficeContentControl[] = [
      {
        Alias: '结果',
        ControlConfig: { placeholder: '请输入结果' },
        ControlRole: 'REPEAT',
        ControlType: 'text',
        InternalId: 'repeat-id',
        Lock: 'unlocked',
        Tag: repeat.controlTag,
      },
    ];

    expect(bridge.snapshotControls([repeat], controls)).toEqual([
      expect.objectContaining({
        repeatGroupCode: 'results',
        repeatPrototypeRowId: 'prototype',
        stepId: 'step-test',
      }),
    ]);
  });

  it('升版复制快照显式允许公式结果主控件和引用继承完整锁', () => {
    const bridge = createOnlyOfficeBridge(createAscFixture().asc);
    const lockedReferenceBinding = {
      ...primary,
      controlRole: 'REFERENCE',
      controlTag: 'eln.ref.result.copy',
      id: 'reference',
      primaryBindingId: primary.id,
    };
    const lockedPrimary: OfficeContentControl = {
      Alias: '结果',
      ControlConfig: { placeholder: '请输入结果' },
      ControlRole: 'PRIMARY',
      ControlType: 'text',
      InternalId: 'locked-primary',
      Lock: 'sdtContentLocked',
      Tag: primary.controlTag,
    };
    const lockedReference: OfficeContentControl = {
      ...lockedPrimary,
      ControlRole: 'REFERENCE',
      InternalId: 'locked-reference',
      Tag: lockedReferenceBinding.controlTag,
    };

    expect(() => bridge.snapshotControls([primary], [lockedPrimary])).toThrow('控件属性与绑定不一致');
    expect(
      bridge.snapshotControls([primary, lockedReferenceBinding], [lockedPrimary, lockedReference], {
        inheritedFormulaLockBindingIds: new Set([primary.id, lockedReferenceBinding.id]),
      }),
    ).toEqual([
      expect.objectContaining({ bindingId: 'primary', controlRole: 'PRIMARY' }),
      expect.objectContaining({ bindingId: 'reference', controlRole: 'REFERENCE' }),
    ]);
    expect(() =>
      bridge.snapshotControls([primary, lockedReferenceBinding], [lockedPrimary, lockedReference], { inheritedFormulaLockBindingIds: new Set([primary.id]) }),
    ).toThrow('控件属性与绑定不一致');
  });

  it('快照校验将非复选框历史空 placeholder 规范为控件别名', () => {
    const historical = {
      ...primary,
      controlConfig: { defaultValue: '', placeholder: '' },
    };
    const control: OfficeContentControl = {
      Alias: '结果',
      ControlConfig: { placeholder: '结果' },
      ControlRole: 'PRIMARY',
      ControlType: 'text',
      InternalId: 'historical-placeholder',
      Lock: 'unlocked',
      Tag: historical.controlTag,
    };

    expect(createOnlyOfficeBridge(createAscFixture().asc).snapshotControls([historical], [control])).toEqual([
      {
        bindingId: 'primary',
        controlAlias: '结果',
        controlConfig: { placeholder: '结果' },
        controlRole: 'PRIMARY',
        controlTag: primary.controlTag,
        controlType: 'TEXT',
        fieldVersionId: 'version',
        primaryBindingId: null,
      },
    ]);
  });

  it('CHECKBOX 升级确认快照忽略字段 defaultChecked 与文档当前勾选态差异', () => {
    const checkbox = {
      ...primary,
      controlConfig: { defaultChecked: true },
      controlType: 'CHECKBOX',
      fieldVersionId: 'version-2',
    };
    const controls: OfficeContentControl[] = [
      {
        Alias: '结果',
        ControlConfig: { defaultChecked: false },
        ControlRole: 'PRIMARY',
        ControlType: 'checkbox',
        InternalId: 'checkbox-control',
        Lock: 'unlocked',
        Tag: checkbox.controlTag,
      },
    ];

    expect(createOnlyOfficeBridge(createAscFixture().asc).snapshotControls([checkbox], controls)).toEqual([
      {
        bindingId: checkbox.id,
        controlAlias: '结果',
        controlConfig: {},
        controlRole: 'PRIMARY',
        controlTag: checkbox.controlTag,
        controlType: 'CHECKBOX',
        fieldVersionId: 'version-2',
        primaryBindingId: null,
      },
    ]);
  });

  it('command 实际枚举结果可直接生成规范化快照，比较不受对象键顺序影响', () => {
    const apiFixture = makeApiFixture();
    const dropdownControl = apiFixture.makeControl('dropdown', primary.controlTag);
    dropdownControl.alias = '结果';
    dropdownControl.placeholder = '请选择结果';
    dropdownControl.options = [
      { display: '合格', value: 'PASS' },
      { display: '不合格', value: 'FAIL' },
    ];
    dropdownControl.elements = [{ text: '合格' }];
    apiFixture.document.controls = [dropdownControl];
    installOnlyOfficeGlobals(apiFixture.Api, { elnTemplateList: {} });
    const enumerated = JSON.parse(listContentControlsCommand()) as { controls: OfficeContentControl[] };
    const dropdownBinding: TemplateBinding = {
      ...primary,
      controlConfig: {
        defaultValue: 'PASS',
        options: [
          { value: 'PASS', display: '合格' },
          { value: 'FAIL', display: '不合格' },
        ],
        placeholder: '请选择结果',
      },
      controlType: 'DROPDOWN',
    };

    expect(createOnlyOfficeBridge(createAscFixture().asc).snapshotControls([dropdownBinding], enumerated.controls)).toEqual([
      expect.objectContaining({
        bindingId: 'primary',
        controlConfig: {
          defaultValue: 'PASS',
          options: [
            { display: '合格', value: 'PASS' },
            { display: '不合格', value: 'FAIL' },
          ],
          placeholder: '请选择结果',
        },
      }),
    ]);
  });

  it('引用快照不要求或提交无法从结构属性证明的默认值', () => {
    const reference = {
      ...primary,
      controlConfig: { defaultValue: '原始默认值', placeholder: '请输入结果' },
      controlRole: 'REFERENCE',
      controlTag: 'eln.ref.result.ref1',
      id: 'reference',
      primaryBindingId: primary.id,
    };
    const controls: OfficeContentControl[] = [
      {
        Alias: '结果',
        ControlConfig: { placeholder: '请输入结果' },
        ControlRole: 'REFERENCE',
        ControlType: 'text',
        InternalId: 'reference-control',
        Lock: 'contentLocked',
        Tag: reference.controlTag,
      },
    ];

    expect(createOnlyOfficeBridge(createAscFixture().asc).snapshotControls([reference], controls)[0]?.controlConfig).toEqual({ placeholder: '请输入结果' });
  });

  it('实际枚举属性缺失或与绑定期望不一致时拒绝生成确认快照', () => {
    const bridge = createOnlyOfficeBridge(createAscFixture().asc);
    expect(() =>
      bridge.snapshotControls(
        [primary],
        [
          {
            Alias: '错误名称',
            ControlConfig: { placeholder: '请输入结果' },
            ControlRole: 'PRIMARY',
            ControlType: 'text',
            InternalId: 'id',
            Lock: 'unlocked',
            Tag: primary.controlTag,
          },
        ],
      ),
    ).toThrow('控件属性与绑定不一致');
    expect(() => bridge.snapshotControls([primary], [{ Alias: '结果', ControlType: 'text', InternalId: 'id', Tag: primary.controlTag }])).toThrow(
      '控件枚举属性不完整',
    );
  });

  it('使用后端 DROPDOWN/MULTILINE 控件枚举而不是字段数据类型枚举', async () => {
    const dropdown = { ...primary, controlType: 'DROPDOWN', controlConfig: { options: ['合格', '不合格'], defaultValue: '合格' } };
    const fixture = createAscFixture({ commandResults: [{ ok: true }, { ok: true }] });
    await createOnlyOfficeBridge(fixture.asc).insertBinding(dropdown);
    expect(fixture.callCommands[0]).toMatchObject({
      command: insertTypedControlCommand,
      payload: expect.objectContaining({ controlType: 'dropdown', selectedIndex: 0 }),
    });
  });

  it('新建多行主控件不再按已有控件重配类型', async () => {
    const multiline = { ...primary, controlType: 'MULTILINE', controlConfig: { placeholder: '请输入检验结果' } };
    const fixture = createAscFixture({ commandResults: [{ ok: true }] });

    await createOnlyOfficeBridge(fixture.asc).insertBinding(multiline);

    expect(fixture.callCommands).toEqual([
      expect.objectContaining({
        command: insertTypedControlCommand,
        payload: expect.objectContaining({ controlType: 'multiline' }),
      }),
    ]);
  });

  it('快照把 ONLYOFFICE 9.4 枚举为 TEXT 的块级绑定规范为 MULTILINE', () => {
    const multiline = { ...primary, controlType: 'MULTILINE', controlConfig: { placeholder: '请输入检验结果' } };
    const control: OfficeContentControl = {
      Alias: '结果',
      ControlConfig: { placeholder: '请输入检验结果' },
      ControlRole: 'PRIMARY',
      ControlType: 'text',
      InternalId: 'multiline-control',
      Lock: 'unlocked',
      Tag: multiline.controlTag,
    };

    expect(createOnlyOfficeBridge(createAscFixture().asc).snapshotControls([multiline], [control])).toEqual([
      expect.objectContaining({ controlType: 'MULTILINE' }),
    ]);
  });

  it('日期时间绑定把字段版本格式和完整默认值传给插入命令', async () => {
    const datetime = {
      ...primary,
      controlType: 'DATE',
      controlConfig: {
        dateFormat: 'yyyy-MM-dd HH:mm:ss',
        defaultValue: '2026-08-01 14:35:27',
      },
    };
    const fixture = createAscFixture({ commandResults: [{ ok: true }, { ok: true }] });

    await createOnlyOfficeBridge(fixture.asc).insertBinding(datetime);

    expect(fixture.callCommands[0]).toMatchObject({
      command: insertTypedControlCommand,
      payload: expect.objectContaining({
        controlType: 'date',
        dateFormat: 'yyyy-MM-dd HH:mm:ss',
        defaultValue: '2026-08-01 14:35:27',
      }),
    });
  });
});