import { countTag } from '../domain/field-types';
import { parseTag } from '../domain/tags';
import type { FieldDefinition, TemplateBinding, TemplateControlSnapshot } from '../domain/types';
import type { FormulaResultLockSnapshot } from '../domain/formula-mapping';
import {
  disableTrackRevisionsCommand,
  insertTypedControlCommand,
  listContentControlsCommand,
  readControlTextCommand,
  readTrackRevisionsStateCommand,
  setFormulaResultLockCommand,
  updateControlSpecCommand,
} from './commands';
import type { AscGlobal, OfficeContentControl, OnlyOfficeCommand } from './types';

interface CommandResult {
  controls?: OfficeContentControl[];
  error?: string;
  hasRevisionChanges?: boolean;
  ok: boolean;
  snapshot?: unknown;
  text?: string;
  trackRevisions?: boolean;
}

interface LifecycleCallbacks {
  onReady: () => void;
  onThemeChanged: (theme: unknown) => void;
}

interface LifecycleBinding {
  callbacks: LifecycleCallbacks;
}

interface LifecycleState {
  bindings: LifecycleBinding[];
  button: NonNullable<AscGlobal['plugin']['button']>;
  init: NonNullable<AscGlobal['plugin']['init']>;
  onThemeChanged: NonNullable<AscGlobal['plugin']['onThemeChanged']>;
  originalButton: AscGlobal['plugin']['button'];
  originalInit: AscGlobal['plugin']['init'];
  originalThemeChanged: AscGlobal['plugin']['onThemeChanged'];
}

export interface SnapshotControlOptions {
  inheritedFormulaLockBindingIds?: ReadonlySet<string>;
}

export interface OnlyOfficeBridge {
  applyControlPlan(bindings: TemplateBinding[], desired: TemplateControlSnapshot[], signal?: AbortSignal): Promise<void>;
  bindLifecycle(callbacks: LifecycleCallbacks): () => void;
  close(): void;
  deleteControl(internalId: string): Promise<OfficeContentControl[]>;
  disableTrackRevisions(): Promise<void>;
  getRuntimeOptions(): unknown;
  insertBinding(binding: TemplateBinding, signal?: AbortSignal): Promise<void>;
  insertReadOnlyBinding(binding: TemplateBinding, signal?: AbortSignal): Promise<void>;
  insertField(definition: FieldDefinition): Promise<OfficeContentControl[]>;
  insertReference(binding: TemplateBinding, primaryTag: string, signal?: AbortSignal): Promise<void>;
  listControls(): Promise<OfficeContentControl[]>;
  lockFormulaResult(primaryTag: string): Promise<FormulaResultLockSnapshot>;
  readSelectedText(): Promise<string>;
  unlockFormulaResult(primaryTag: string): Promise<void>;
  restoreFormulaResultLocks(snapshot: FormulaResultLockSnapshot): Promise<void>;
  isFormulaResultLocked(primaryTag: string): Promise<boolean>;
  selectControl(internalId: string, signal?: AbortSignal): Promise<void>;
  snapshotControls(bindings: TemplateBinding[], controls: OfficeContentControl[], options?: SnapshotControlOptions): TemplateControlSnapshot[];
}

function isFormulaLockSnapshot(value: unknown): value is FormulaResultLockSnapshot {
  return (
    typeof value === 'object' &&
    value !== null &&
    'primaryTag' in value &&
    typeof value.primaryTag === 'string' &&
    'locks' in value &&
    Array.isArray(value.locks) &&
    value.locks.every(
      (item) => typeof item === 'object' && item !== null && 'tag' in item && typeof item.tag === 'string' && 'lock' in item && typeof item.lock === 'string',
    )
  );
}

const lifecycleStates = new WeakMap<AscGlobal, LifecycleState>();

function debugBridge(event: string, details: Record<string, unknown>): void {
  if (import.meta.env.DEV && import.meta.env.MODE !== 'test') {
    console.info('[ELN annotator]', new Date().toISOString(), event, details);
  }
}

function toError(error: unknown): Error {
  return error instanceof Error ? error : new Error(String(error));
}

function normalizeOptions(value: unknown): Array<{ display: string; value: string }> {
  if (!Array.isArray(value)) return [];
  return value.map((item) => {
    if (typeof item === 'object' && item && 'display' in item && 'value' in item) {
      return { display: String(item.display), value: String(item.value) };
    }
    return { display: String(item), value: String(item) };
  });
}

function normalizeControlConfig(controlType: string, controlRole: string, value: null | Record<string, unknown> | undefined): Record<string, unknown> {
  const config = value ?? {};
  const placeholder = typeof config.placeholder === 'string' ? config.placeholder : '';
  switch (controlType.toUpperCase()) {
    case 'DROPDOWN':
      return {
        options: normalizeOptions(config.options),
        placeholder,
        ...(controlRole === 'PRIMARY' ? { defaultValue: typeof config.defaultValue === 'string' ? config.defaultValue : '' } : {}),
      };
    case 'CHECKBOX':
      return { defaultChecked: Boolean(config.defaultChecked) };
    case 'DATE':
      return { dateFormat: typeof config.dateFormat === 'string' && config.dateFormat ? config.dateFormat : 'yyyy-MM-dd', placeholder };
    case 'MULTILINE':
    case 'TEXT':
      return { placeholder };
    default:
      return config;
  }
}

function normalizeExistingControlConfig(controlType: string, controlRole: string, value: null | Record<string, unknown> | undefined): Record<string, unknown> {
  if (controlType.toUpperCase() === 'CHECKBOX') return {};
  return normalizeControlConfig(controlType, controlRole, value);
}

function bindingConfigForSnapshot(binding: TemplateBinding): null | Record<string, unknown> {
  const config = binding.controlConfig ?? {};
  const placeholder = typeof config.placeholder === 'string' ? config.placeholder : '';
  if (binding.controlType !== 'CHECKBOX' && !placeholder.trim()) {
    return { ...config, placeholder: binding.controlAlias || binding.fieldCode };
  }
  return binding.controlConfig;
}

function stableValue(value: unknown): unknown {
  if (Array.isArray(value)) return value.map(stableValue);
  if (value && typeof value === 'object') {
    return Object.fromEntries(
      Object.entries(value)
        .sort(([left], [right]) => left.localeCompare(right))
        .map(([key, item]) => [key, stableValue(item)]),
    );
  }
  return value;
}

function configsEqual(left: Record<string, unknown>, right: Record<string, unknown>): boolean {
  return JSON.stringify(stableValue(left)) === JSON.stringify(stableValue(right));
}

function snapshotControlType(bindingType: string, actualType: string): string {
  const expected = bindingType.toUpperCase();
  const actual = actualType.toUpperCase();
  return expected === 'MULTILINE' && actual === 'TEXT' ? expected : actual;
}

function bindingLock(binding: TemplateBinding, role = binding.controlRole): 'contentLocked' | 'sdtContentLocked' | 'unlocked' {
  if (role === 'REFERENCE') return 'contentLocked';
  return binding.readOnly === true && binding.valueSource === 'CROSS_TEMPLATE' ? 'sdtContentLocked' : 'unlocked';
}

function controlMatchesTarget(binding: TemplateBinding, target: TemplateControlSnapshot, control: OfficeContentControl): boolean {
  if (
    typeof control.Alias !== 'string' ||
    !control.ControlConfig ||
    typeof control.ControlRole !== 'string' ||
    typeof control.ControlType !== 'string' ||
    typeof control.Lock !== 'string'
  )
    return false;
  const role = target.controlRole || binding.controlRole;
  const type = (target.controlType || binding.controlType).toUpperCase();
  const alias = target.controlAlias || binding.controlAlias || binding.fieldCode;
  const expectedConfig = normalizeExistingControlConfig(type, role, target.controlConfig ?? binding.controlConfig);
  const actualConfig = normalizeExistingControlConfig(control.ControlType, control.ControlRole, control.ControlConfig);
  return (
    control.Alias === alias &&
    control.ControlRole === role &&
    control.ControlType.toUpperCase() === type &&
    control.Lock === bindingLock(binding, role) &&
    configsEqual(actualConfig, expectedConfig)
  );
}

function isCommandResult(value: unknown): value is CommandResult {
  return typeof value === 'object' && value !== null && !Array.isArray(value) && 'ok' in value && typeof value.ok === 'boolean';
}

function bindLifecycleHandlers(asc: AscGlobal, callbacks: LifecycleCallbacks): () => void {
  let state = lifecycleStates.get(asc);

  if (!state) {
    const bindings: LifecycleBinding[] = [];
    const currentBinding = () => bindings[bindings.length - 1];
    state = {
      bindings,
      originalInit: asc.plugin.init,
      originalButton: asc.plugin.button,
      originalThemeChanged: asc.plugin.onThemeChanged,
      init: () => currentBinding()?.callbacks.onReady(),
      button: (id) => {
        if (id === -1 && currentBinding()) {
          asc.plugin.executeCommand('close', '');
        }
      },
      onThemeChanged: (theme) => {
        if (currentBinding()) {
          asc.plugin.onThemeChangedBase(theme);
          currentBinding()?.callbacks.onThemeChanged(theme);
        }
      },
    };
    lifecycleStates.set(asc, state);
    asc.plugin.init = state.init;
    asc.plugin.button = state.button;
    asc.plugin.onThemeChanged = state.onThemeChanged;
  }

  const binding = { callbacks };
  state.bindings.push(binding);
  let active = true;

  return () => {
    if (!active) {
      return;
    }
    active = false;
    const index = state.bindings.indexOf(binding);
    if (index >= 0) {
      state.bindings.splice(index, 1);
    }
    if (state.bindings.length > 0) {
      return;
    }

    if (asc.plugin.init === state.init) {
      asc.plugin.init = state.originalInit;
    }
    if (asc.plugin.button === state.button) {
      asc.plugin.button = state.originalButton;
    }
    if (asc.plugin.onThemeChanged === state.onThemeChanged) {
      asc.plugin.onThemeChanged = state.originalThemeChanged;
    }
    if (lifecycleStates.get(asc) === state) {
      lifecycleStates.delete(asc);
    }
  };
}

export function createOnlyOfficeBridge(asc: AscGlobal): OnlyOfficeBridge {
  let verifyNativeControlTag = '';
  let preferNativeControls = false;
  const insertedTextDefinitions = new Map<string, FieldDefinition>();

  function executeMethod(name: string, args: unknown[] = []): Promise<unknown> {
    return new Promise((resolve, reject) => {
      try {
        debugBridge('method:start', { args, methodName: name });
        asc.plugin.executeMethod(name, args, (result) => {
          debugBridge('method:callback', { methodName: name, result });
          resolve(result);
        });
      } catch (error: unknown) {
        debugBridge('method:threw', { error: toError(error).message, methodName: name });
        reject(toError(error));
      }
    });
  }

  function executeCommand(command: OnlyOfficeCommand, scopeKey: string, payload: unknown, allowMissingResult = false): Promise<CommandResult> {
    return new Promise((resolve, reject) => {
      const commandName = command.name || scopeKey;
      const clearScope = () => {
        if (asc.scope[scopeKey] === payload) {
          delete asc.scope[scopeKey];
        }
      };

      try {
        asc.scope[scopeKey] = payload;
        debugBridge('command:start', { allowMissingResult, commandName, payload, scopeKey });
        asc.plugin.callCommand(command, false, true, (raw) => {
          try {
            debugBridge('command:callback', { commandName, raw, scopeKey });
            if (raw === undefined && allowMissingResult) {
              debugBridge('command:missing-callback-accepted', { commandName, scopeKey });
              resolve({ ok: true });
              return;
            }
            const result: unknown = typeof raw === 'string' ? JSON.parse(raw) : raw;

            if (!isCommandResult(result)) {
              debugBridge('command:invalid-result', { commandName, raw, scopeKey });
              reject(new Error('编辑器命令返回无效结果'));
              return;
            }

            if (!result.ok) {
              debugBridge('command:rejected', { commandName, error: result.error, scopeKey });
              reject(new Error(typeof result.error === 'string' ? result.error : '编辑器命令执行失败'));
              return;
            }

            debugBridge('command:success', { commandName, scopeKey });
            resolve(result);
          } catch {
            debugBridge('command:invalid-result', { commandName, raw, scopeKey });
            reject(new Error('编辑器命令返回无效结果'));
          } finally {
            clearScope();
          }
        });
      } catch (error: unknown) {
        clearScope();
        debugBridge('command:threw', { commandName, error: toError(error).message, scopeKey });
        reject(toError(error));
      }
    });
  }

  async function readControls(errorMessage: string): Promise<OfficeContentControl[]> {
    const result = await executeCommand(listContentControlsCommand, 'elnTemplateList', {});

    if (!Array.isArray(result.controls)) {
      throw new Error(errorMessage);
    }

    const targetTag = verifyNativeControlTag;
    const commandTargetCount = targetTag ? countTag(result.controls, targetTag) : 0;
    const shouldReadNative = preferNativeControls || Boolean(targetTag && commandTargetCount === 0);
    verifyNativeControlTag = '';
    if (!shouldReadNative) return result.controls;

    const rawNative = await executeMethod('GetAllContentControls');
    if (!Array.isArray(rawNative)) throw new Error(errorMessage);
    const native = rawNative.map((item) => nativeControl(item)).filter((control): control is OfficeContentControl => control !== null);
    const nativeTargetCount = targetTag ? countTag(native, targetTag) : 0;
    if (targetTag && commandTargetCount === 0 && nativeTargetCount > 0) preferNativeControls = true;

    return preferNativeControls ? mergeNativeControls(native, result.controls) : result.controls;
  }

  function nativeLock(value: unknown): string | undefined {
    if (typeof value === 'string') return value;
    if (value === 0) return 'contentLocked';
    if (value === 1) return 'sdtContentLocked';
    if (value === 2) return 'sdtLocked';
    if (value === 3) return 'unlocked';
    return undefined;
  }

  function nativeControl(value: unknown): null | OfficeContentControl {
    if (!value || typeof value !== 'object') return null;
    const item = value as Record<string, unknown>;
    const tag = typeof item.Tag === 'string' ? item.Tag : '';
    const definition = insertedTextDefinitions.get(tag);
    const controlRole = tag.startsWith('eln.ref.')
      ? 'REFERENCE'
      : tag.startsWith('eln.field.')
        ? 'PRIMARY'
        : tag.startsWith('eln.repeat.')
          ? 'REPEAT'
          : 'UNKNOWN';
    return {
      Alias: typeof item.Alias === 'string' ? item.Alias : undefined,
      ControlConfig: definition ? { placeholder: definition.placeholder } : undefined,
      ControlRole: definition ? controlRole : undefined,
      ControlType: definition ? 'text' : undefined,
      InternalId: typeof item.InternalId === 'string' ? item.InternalId : undefined,
      Lock: nativeLock(item.Lock),
      Tag: tag,
    };
  }

  function mergeNativeControls(native: OfficeContentControl[], detailed: OfficeContentControl[]): OfficeContentControl[] {
    return native.map((control) => {
      const match = detailed.find((item) => (control.InternalId && item.InternalId === control.InternalId) || (control.Tag && item.Tag === control.Tag));
      if (!match) return control;
      return {
        ...match,
        ...control,
        Alias: control.Alias ?? match.Alias,
        ControlConfig: match.ControlConfig ?? control.ControlConfig,
        ControlRole: match.ControlRole ?? control.ControlRole,
        ControlType: control.Tag && insertedTextDefinitions.has(control.Tag) ? control.ControlType : (match.ControlType ?? control.ControlType),
        InternalId: control.InternalId ?? match.InternalId,
        Lock: control.Lock ?? match.Lock,
        Tag: control.Tag || match.Tag,
      };
    });
  }

  async function writeTextDefaultWithNativeControl(tag: string, value: string): Promise<void> {
    const rawControls = await executeMethod('GetAllContentControls');
    if (!Array.isArray(rawControls)) throw new Error('插入后无法读取文本控件');
    const targets = rawControls.map((item) => nativeControl(item)).filter((control): control is OfficeContentControl => control?.Tag === tag);
    if (targets.length !== 1) throw new Error('插入后 Tag 计数不是 1');
    const target = targets[0]!;
    if (!target?.InternalId) throw new Error('插入后无法定位文本控件');

    const moved = await executeMethod('MoveCursorToContentControl', [target.InternalId, true]);
    if (moved === false) throw new Error('插入后无法定位文本控件');
    const input = await executeMethod('InputText', [value]);
    if (input === false) throw new Error('文本默认值写入失败');
    const rawCurrent = await executeMethod('GetCurrentContentControlPr', ['text']);
    const current = rawCurrent && typeof rawCurrent === 'object' ? (rawCurrent as Record<string, unknown>) : null;
    if (current?.InternalId !== target.InternalId || current.Tag !== tag) throw new Error('文本默认值写入后控件定位不一致');
    if (current?.content !== value) throw new Error('文本默认值回读不一致');
  }

  function listControls(): Promise<OfficeContentControl[]> {
    return readControls('编辑器未返回内容控件列表');
  }

  async function readSelectedText(): Promise<string> {
    const result = await executeMethod('GetSelectedText', [{ Math: false, Numbering: false }]);
    return typeof result === 'string' ? result : '';
  }

  async function disableTrackRevisions(): Promise<void> {
    await executeCommand(disableTrackRevisionsCommand, 'elnTemplateReview', {}, true);
    const state = await executeCommand(readTrackRevisionsStateCommand, 'elnTemplateReviewState', {});
    if (state.hasRevisionChanges !== false) {
      throw new Error('历史修订仍未全部接受');
    }
    if (state.trackRevisions !== false) {
      throw new Error('修订跟踪仍处于开启状态');
    }
  }

  async function lockFormulaResult(primaryTag: string): Promise<FormulaResultLockSnapshot> {
    const result = await executeCommand(setFormulaResultLockCommand, 'elnTemplateFormulaLocks', { mode: 'lock', primaryTag });
    if (!isFormulaLockSnapshot((result as { snapshot?: unknown }).snapshot)) throw new Error('编辑器未返回公式结果锁快照');
    return (result as { snapshot: FormulaResultLockSnapshot }).snapshot;
  }

  async function restoreFormulaResultLocks(snapshot: FormulaResultLockSnapshot): Promise<void> {
    const result = await executeCommand(setFormulaResultLockCommand, 'elnTemplateFormulaLocks', { mode: 'restore', snapshot });
    if (!isFormulaLockSnapshot((result as { snapshot?: unknown }).snapshot)) throw new Error('编辑器未确认公式结果锁恢复');
  }

  async function unlockFormulaResult(primaryTag: string): Promise<void> {
    const result = await executeCommand(setFormulaResultLockCommand, 'elnTemplateFormulaLocks', { mode: 'unlock', primaryTag });
    if (!isFormulaLockSnapshot((result as { snapshot?: unknown }).snapshot)) throw new Error('编辑器未确认公式结果锁解除');
  }

  async function isFormulaResultLocked(primaryTag: string): Promise<boolean> {
    const result = await executeCommand(setFormulaResultLockCommand, 'elnTemplateFormulaLocks', {
      mode: 'verify',
      primaryTag,
    });
    return isFormulaLockSnapshot((result as { snapshot?: unknown }).snapshot);
  }

  async function insertField(definition: FieldDefinition): Promise<OfficeContentControl[]> {
    const before = await listControls();
    const beforeCount = countTag(before, definition.tag);
    debugBridge('field:before-insert', { beforeCount, controlType: definition.controlType, tag: definition.tag });

    if (beforeCount > 0) {
      throw new Error('字段 ID 已存在');
    }

    const alias = definition.alias.trim();
    if (before.some((control) => parseTag(control.Tag) && (control.Alias || '').trim() === alias)) {
      throw new Error('字段名称已存在');
    }

    await writeDefinition(definition);

    const after = await readControls('插入后无法读取内容控件列表');
    const afterCount = countTag(after, definition.tag);
    debugBridge('field:after-insert', { afterCount, beforeCount, controlType: definition.controlType, tag: definition.tag });
    if (afterCount !== beforeCount + 1) {
      throw new Error('插入后 Tag 计数未增加');
    }

    return after;
  }

  async function writeDefinition(definition: FieldDefinition, lock?: 'contentLocked' | 'sdtContentLocked' | 'unlocked', signal?: AbortSignal): Promise<void> {
    if (signal?.aborted) return;
    const currentControlId = await executeMethod('GetCurrentContentControl');
    if (signal?.aborted) return;
    if (typeof currentControlId === 'string' && currentControlId) {
      throw new Error('请将光标移到已有字段控件外再插入');
    }

    if (definition.controlType === 'text') {
      const result = await executeMethod('AddContentControl', [
        2,
        {
          Tag: definition.tag,
          Alias: definition.alias,
          Lock: lock === 'contentLocked' ? 0 : lock === 'sdtContentLocked' ? 1 : 3,
          PlaceHolderText: definition.placeholder,
          Appearance: 1,
          Color: definition.color,
        },
      ]);
      if (signal?.aborted) return;
      if (
        !result ||
        typeof result !== 'object' ||
        typeof (result as Record<string, unknown>).InternalId !== 'string' ||
        (result as Record<string, unknown>).Tag !== definition.tag
      ) {
        throw new Error('编辑器未能在光标位置插入文本控件，请在目标位置单击出现文字光标后重试');
      }

      insertedTextDefinitions.set(definition.tag, definition);
      verifyNativeControlTag = definition.tag;
      if (definition.defaultValue) {
        await writeTextDefaultWithNativeControl(definition.tag, definition.defaultValue);
        if (signal?.aborted) return;
      }
      return;
    }

    const isDropdown = definition.controlType === 'dropdown';
    await executeCommand(
      insertTypedControlCommand,
      'elnTemplateInsert',
      {
        controlType: definition.controlType,
        tag: definition.tag,
        alias: definition.alias,
        placeholder: definition.placeholder,
        dateFormat: 'dateFormat' in definition ? definition.dateFormat : undefined,
        debug: import.meta.env.DEV,
        defaultValue: isDropdown ? '' : definition.defaultValue,
        defaultChecked: isDropdown ? false : definition.defaultChecked,
        options: isDropdown ? definition.options : [],
        selectedIndex: isDropdown ? definition.selectedIndex : -1,
        color: definition.color,
        lock,
      },
      true,
    );
    if (signal?.aborted) return;

    if (lock === 'contentLocked') {
      await updateControlSpec({
        ...bindingSpec(definition),
        currentTag: definition.tag,
        lock,
        tag: definition.tag,
      });
    }
  }

  function bindingSpec(definition: FieldDefinition) {
    return {
      alias: definition.alias,
      controlConfig: {
        placeholder: definition.placeholder,
        ...('defaultValue' in definition ? { defaultValue: definition.defaultValue } : {}),
        ...('defaultChecked' in definition ? { defaultChecked: definition.defaultChecked } : {}),
        ...('dateFormat' in definition && definition.dateFormat ? { dateFormat: definition.dateFormat } : {}),
        ...('options' in definition ? { options: definition.options } : {}),
      },
      controlType: definition.controlType.toUpperCase(),
    };
  }

  function definitionFromBinding(binding: TemplateBinding, currentText?: string): FieldDefinition {
    const config = binding.controlConfig ?? {};
    const alias = binding.controlAlias || binding.fieldCode;
    const configuredPlaceholder = typeof config.placeholder === 'string' ? config.placeholder : '';
    const placeholder = configuredPlaceholder.trim() || alias;
    const rawOptions = Array.isArray(config.options) ? config.options : [];
    const options = rawOptions.map((item) => {
      if (typeof item === 'object' && item && 'display' in item && 'value' in item) return { display: String(item.display), value: String(item.value) };
      return { display: String(item), value: String(item) };
    });
    const base = { fieldCode: binding.fieldCode, alias, tag: binding.controlTag, color: { R: 23, G: 109, B: 92 } };
    if (binding.controlType === 'DROPDOWN') {
      const value = currentText ?? String(config.defaultValue ?? '');
      return {
        ...base,
        controlType: 'dropdown',
        placeholder,
        options,
        selectedIndex: options.findIndex((item) => item.display === value || item.value === value),
      };
    }
    if (binding.controlType === 'CHECKBOX')
      return {
        ...base,
        controlType: 'checkbox',
        placeholder: '',
        defaultValue: '',
        defaultChecked: currentText ? /^(?:true|1|☑|是)$/iu.test(currentText) : Boolean(config.defaultChecked),
      };
    if (binding.controlType === 'DATE')
      return {
        ...base,
        controlType: 'date',
        dateFormat: typeof config.dateFormat === 'string' && config.dateFormat ? config.dateFormat : 'yyyy-MM-dd',
        placeholder,
        defaultValue: currentText ?? String(config.defaultValue ?? ''),
        defaultChecked: false,
      };
    if (binding.controlType === 'MULTILINE')
      return { ...base, controlType: 'multiline', placeholder, defaultValue: currentText ?? String(config.defaultValue ?? ''), defaultChecked: false };
    return { ...base, controlType: 'text', placeholder, defaultValue: currentText ?? String(config.defaultValue ?? ''), defaultChecked: false };
  }

  function updateControlSpec(update: {
    alias: string;
    controlConfig: null | Record<string, unknown>;
    controlType: string;
    currentTag: string;
    lock: 'contentLocked' | 'sdtContentLocked' | 'unlocked';
    tag: string;
  }): Promise<CommandResult> {
    return executeCommand(updateControlSpecCommand, 'elnTemplateUpdateControls', { removals: [], updates: [update] });
  }

  async function insertBinding(binding: TemplateBinding, signal?: AbortSignal): Promise<void> {
    if (signal?.aborted) return;
    await writeDefinition(definitionFromBinding(binding), bindingLock(binding), signal);
  }

  async function insertReadOnlyBinding(binding: TemplateBinding, signal?: AbortSignal): Promise<void> {
    if (signal?.aborted) return;
    await writeDefinition(definitionFromBinding(binding), 'sdtContentLocked', signal);
  }

  async function insertReference(binding: TemplateBinding, primaryTag: string, signal?: AbortSignal): Promise<void> {
    if (signal?.aborted) return;
    const result = await executeCommand(readControlTextCommand, 'elnTemplateReadText', { tag: primaryTag });
    if (signal?.aborted) return;
    await writeDefinition(definitionFromBinding(binding, typeof result.text === 'string' ? result.text : ''), 'contentLocked', signal);
  }

  async function applyControlPlan(bindings: TemplateBinding[], desired: TemplateControlSnapshot[], signal?: AbortSignal): Promise<void> {
    if (signal?.aborted) return;
    const controls = await listControls();
    if (signal?.aborted) return;
    const desiredById = new Map(desired.map((item) => [item.bindingId, item]));
    const alreadyAppliedIds = new Set<string>();
    const appliedTargetTags = new Set<string>();
    for (const binding of bindings.filter((item) => item.status === 'ACTIVE')) {
      const target = desiredById.get(binding.id);
      if (!target) continue;
      const currentMatches = controls.filter((item) => item.Tag === binding.controlTag);
      if (target.controlTag === binding.controlTag) {
        if (currentMatches.length === 1 && controlMatchesTarget(binding, target, currentMatches[0]!)) alreadyAppliedIds.add(binding.id);
        continue;
      }
      if (currentMatches.length > 0) continue;
      const matches = controls.filter((item) => item.Tag === target.controlTag);
      if (matches.length === 1 && controlMatchesTarget(binding, target, matches[0]!)) {
        alreadyAppliedIds.add(binding.id);
        appliedTargetTags.add(target.controlTag);
      }
    }
    const removals: string[] = [];
    const updates: Array<{
      alias: string;
      controlConfig: null | Record<string, unknown>;
      controlType: string;
      currentTag: string;
      lock: 'contentLocked' | 'sdtContentLocked' | 'unlocked';
      tag: string;
    }> = [];
    for (const binding of bindings.filter((item) => item.status === 'ACTIVE')) {
      const target = desiredById.get(binding.id);
      const control = controls.find((item) => item.Tag === binding.controlTag);
      if (!target) {
        if (control && !appliedTargetTags.has(binding.controlTag)) removals.push(binding.controlTag);
        continue;
      }
      if (alreadyAppliedIds.has(binding.id)) continue;
      if (!control) throw new Error(`待更新控件不存在：${binding.controlTag}`);
      const targetType = (target.controlType || binding.controlType).toUpperCase();
      if (typeof control.ControlType === 'string' && control.ControlType.toUpperCase() !== targetType) {
        throw new Error('当前阶段不支持修改已有控件类型');
      }
      const currentPlaceholder = control.ControlConfig?.placeholder;
      const targetPlaceholder = (target.controlConfig ?? binding.controlConfig)?.placeholder;
      if (targetType !== 'CHECKBOX' && targetPlaceholder === '' && typeof currentPlaceholder === 'string' && currentPlaceholder !== '') {
        throw new Error('当前编辑器不支持清空已有占位文本');
      }
      updates.push({
        currentTag: binding.controlTag,
        tag: target.controlTag,
        alias: target.controlAlias || binding.controlAlias || binding.fieldCode,
        controlType: targetType,
        controlConfig: target.controlConfig ?? binding.controlConfig,
        lock: bindingLock(binding, target.controlRole ?? binding.controlRole),
      });
    }
    if (signal?.aborted) return;
    if (removals.length > 1) throw new Error('当前阶段不支持一次删除多个控件');
    if (updates.length || removals.length) await executeCommand(updateControlSpecCommand, 'elnTemplateUpdateControls', { removals, updates });
  }

  function snapshotControls(bindings: TemplateBinding[], controls: OfficeContentControl[], options: SnapshotControlOptions = {}): TemplateControlSnapshot[] {
    return bindings.map((binding) => {
      const matches = controls.filter((control) => control.Tag === binding.controlTag);
      if (matches.length !== 1) throw new Error(`控件枚举数量异常：${binding.controlTag}`);
      const control = matches[0]!;
      if (
        typeof control.Alias !== 'string' ||
        !control.ControlConfig ||
        typeof control.ControlRole !== 'string' ||
        typeof control.ControlType !== 'string' ||
        typeof control.Lock !== 'string'
      ) {
        throw new Error(`控件枚举属性不完整：${binding.controlTag}`);
      }
      const actualType = snapshotControlType(binding.controlType, control.ControlType);
      const actualConfig = normalizeExistingControlConfig(actualType, control.ControlRole, control.ControlConfig);
      const expectedConfig = normalizeExistingControlConfig(binding.controlType, binding.controlRole, bindingConfigForSnapshot(binding));
      const expectedLock = bindingLock(binding, control.ControlRole);
      const lockMatches = control.Lock === expectedLock || (control.Lock === 'sdtContentLocked' && options.inheritedFormulaLockBindingIds?.has(binding.id));
      if (
        control.Alias !== (binding.controlAlias ?? '') ||
        actualType !== binding.controlType ||
        control.ControlRole !== binding.controlRole ||
        !configsEqual(actualConfig, expectedConfig) ||
        !lockMatches
      ) {
        throw new Error(`控件属性与绑定不一致：${binding.controlTag}`);
      }
      return {
        bindingId: binding.id,
        controlTag: control.Tag!,
        controlAlias: control.Alias,
        controlType: actualType,
        controlRole: control.ControlRole,
        fieldVersionId: binding.fieldVersionId,
        primaryBindingId: binding.primaryBindingId,
        repeatGroupCode: binding.repeatGroupCode,
        repeatPrototypeRowId: binding.repeatPrototypeRowId,
        stepId: binding.stepId,
        controlConfig: actualConfig,
      };
    });
  }

  async function selectControl(internalId: string, signal?: AbortSignal): Promise<void> {
    if (!internalId) {
      throw new Error('该内容控件没有可用的内部 ID');
    }
    if (signal?.aborted) return;

    const controls = await listControls();
    if (signal?.aborted) return;
    if (!controls.some((control) => control.InternalId === internalId)) {
      throw new Error('定位目标已不存在，请刷新字段列表');
    }

    const result = await executeMethod('SelectContentControl', [internalId]);
    if (result === false) {
      throw new Error('编辑器未能定位字段');
    }
  }

  async function deleteControl(internalId: string): Promise<OfficeContentControl[]> {
    if (!internalId) {
      throw new Error('该内容控件没有可用的内部 ID');
    }

    const before = await listControls();
    if (!before.some((control) => control.InternalId === internalId)) {
      throw new Error('删除目标已不存在，请刷新字段列表');
    }

    if ((await executeMethod('RemoveContentControl', [internalId])) === false) {
      throw new Error('编辑器未能移除字段控件');
    }

    const after = await readControls('解除后无法读取内容控件列表');
    if (after.some((control) => control.InternalId === internalId)) {
      throw new Error('解除后字段仍然存在');
    }
    return after;
  }

  function close(): void {
    asc.plugin.executeCommand('close', '');
  }

  function getRuntimeOptions(): unknown {
    return asc.plugin.info?.options;
  }

  function bindLifecycle(callbacks: LifecycleCallbacks): () => void {
    return bindLifecycleHandlers(asc, callbacks);
  }

  return {
    applyControlPlan,
    bindLifecycle,
    close,
    deleteControl,
    disableTrackRevisions,
    getRuntimeOptions,
    insertBinding,
    insertReadOnlyBinding,
    insertField,
    insertReference,
    isFormulaResultLocked,
    listControls,
    lockFormulaResult,
    readSelectedText,
    restoreFormulaResultLocks,
    selectControl,
    snapshotControls,
    unlockFormulaResult,
  };
}