import type { DocumentField, FieldApplyResult, FieldChange } from '../domain/types';
import { applyFieldsCommand, cloneRepeatRowCommand, inspectFieldsCommand, removeRepeatRowCommand } from './commands';
import type { ApplyResult, AscGlobal, InspectResult, RepeatCloneResult } from './types';

export interface EditorControlEvent {
  InternalId?: unknown;
  Tag?: unknown;
}

interface LifecycleCallbacks {
  onControlChanged: (control: EditorControlEvent) => void;
  onControlFocused: (control: EditorControlEvent) => void;
  onReady: () => void;
  onThemeChanged: (theme: unknown) => void;
}

export interface OnlyOfficeBridge {
  applyFields(changes: FieldChange[]): Promise<FieldApplyResult[]>;
  appendRepeatRow(groupCode: string, rowId: string, beforeRowId?: string): Promise<string[]>;
  bindLifecycle(callbacks: LifecycleCallbacks): () => void;
  getRuntimeOptions(): unknown;
  inspectFields(): Promise<DocumentField[]>;
  removeRepeatRow(groupCode: string, rowId: string): Promise<string[]>;
  selectControl(internalId: string): Promise<void>;
  setFillOnlyMode(enabled: boolean): Promise<void>;
}

function parseResult<T>(raw: unknown): T {
  const result: unknown = typeof raw === 'string' ? JSON.parse(raw) : raw;
  if (typeof result !== 'object' || result === null || Array.isArray(result) || !('ok' in result) || typeof result.ok !== 'boolean') {
    throw new Error('编辑器命令返回无效结果');
  }
  return result as T;
}

export function createOnlyOfficeBridge(asc: AscGlobal): OnlyOfficeBridge {
  let fillOnlyMode = false;
  let documentCommandQueue: Promise<void> = Promise.resolve();

  function executeMethod(name: string, args: unknown[] = []): Promise<unknown> {
    return new Promise((resolve, reject) => {
      try {
        asc.plugin.executeMethod(name, args, resolve);
      } catch (error) {
        reject(error);
      }
    });
  }

  function enqueueDocumentCommand<T>(operation: () => Promise<T>): Promise<T> {
    const result = documentCommandQueue.then(operation, operation);
    documentCommandQueue = result.then(() => undefined, () => undefined);
    return result;
  }

  async function applyFillOnlyRestriction(): Promise<void> {
    try {
      await executeMethod('SetEditingRestrictions', ['forms']);
    } catch (error) {
      try {
        await executeMethod('SetEditingRestrictions', ['readOnly']);
      } catch {
        // Preserve the first failure; read-only is a best-effort fail-closed fallback.
      }
      throw error;
    }
  }

  function callCommandRaw<T>(command: () => string, scopeKey: string, payload: unknown): Promise<T> {
    return new Promise((resolve, reject) => {
      asc.scope[scopeKey] = payload;
      try {
        asc.plugin.callCommand(command, false, true, (raw) => {
          try { resolve(parseResult<T>(raw)); } catch (error) { reject(error); }
          finally { delete asc.scope[scopeKey]; }
        });
      } catch (error) {
        delete asc.scope[scopeKey];
        reject(error);
      }
    });
  }

  function callCommand<T>(command: () => string, scopeKey: string, payload: unknown): Promise<T> {
    if (!fillOnlyMode) return callCommandRaw<T>(command, scopeKey, payload);
    return enqueueDocumentCommand(async () => {
      await executeMethod('SetEditingRestrictions', ['none']);
      try {
        return await callCommandRaw<T>(command, scopeKey, payload);
      } finally {
        await applyFillOnlyRestriction();
      }
    });
  }

  async function inspectFields(): Promise<DocumentField[]> {
    const result = await callCommand<InspectResult>(inspectFieldsCommand, 'elnRecordFillInspect', {});
    if (!result.ok) throw new Error(result.error || '读取内容控件失败');
    return result.fields;
  }

  async function applyFields(changes: FieldChange[]): Promise<FieldApplyResult[]> {
    const result = await callCommand<ApplyResult>(applyFieldsCommand, 'elnRecordFillChanges', changes);
    if (!result.ok) throw new Error(result.error || '应用字段失败');
    return result.results;
  }

  async function appendRepeatRow(groupCode: string, rowId: string, beforeRowId?: string): Promise<string[]> {
    const result = await callCommand<RepeatCloneResult>(cloneRepeatRowCommand, 'elnRecordFillRepeatRow', {
      ...(beforeRowId ? { beforeRowId } : {}), groupCode, rowId,
    });
    if (!result.ok || !Array.isArray(result.tags)) throw new Error(result.error || '新增文档重复行失败');
    return result.tags;
  }

  async function removeRepeatRow(groupCode: string, rowId: string): Promise<string[]> {
    const result = await callCommand<RepeatCloneResult>(removeRepeatRowCommand, 'elnRecordFillRepeatRow', { groupCode, rowId });
    if (!result.ok || !Array.isArray(result.tags)) throw new Error(result.error || '删除文档重复行失败');
    return result.tags;
  }

  async function selectControl(internalId: string): Promise<void> {
    if (!internalId) throw new Error('字段控件缺少内部 ID');
    if (await executeMethod('SelectContentControl', [internalId]) === false) {
      throw new Error('编辑器未能定位字段');
    }
  }

  function bindLifecycle(callbacks: LifecycleCallbacks): () => void {
    const originalInit = asc.plugin.init;
    const originalTheme = asc.plugin.onThemeChanged;
    const changeEvent = 'onChangeContentControl';
    const focusEvent = 'onFocusContentControl';
    const onControlChanged = (value: unknown) => callbacks.onControlChanged(
      typeof value === 'object' && value !== null ? value as EditorControlEvent : {},
    );
    const onControlFocused = (value: unknown) => callbacks.onControlFocused(
      typeof value === 'object' && value !== null ? value as EditorControlEvent : {},
    );
    let eventsAttached = false;
    const onReady = () => {
      if (!eventsAttached) {
        asc.plugin.attachEditorEvent?.(changeEvent, onControlChanged);
        asc.plugin.attachEditorEvent?.(focusEvent, onControlFocused);
        eventsAttached = true;
      }
      callbacks.onReady();
    };
    asc.plugin.init = onReady;
    asc.plugin.onThemeChanged = (theme) => { asc.plugin.onThemeChangedBase(theme); callbacks.onThemeChanged(theme); };
    return () => {
      if (asc.plugin.init === onReady) asc.plugin.init = originalInit;
      asc.plugin.onThemeChanged = originalTheme;
      if (eventsAttached) {
        asc.plugin.detachEditorEvent?.(changeEvent);
        asc.plugin.detachEditorEvent?.(focusEvent);
      }
    };
  }

  return {
    applyFields,
    appendRepeatRow,
    bindLifecycle,
    getRuntimeOptions: () => asc.plugin.info?.options,
    inspectFields,
    removeRepeatRow,
    selectControl,
    setFillOnlyMode: (enabled) => enqueueDocumentCommand(async () => {
      fillOnlyMode = enabled;
      if (enabled) await applyFillOnlyRestriction();
      else await executeMethod('SetEditingRestrictions', ['none']);
    }),
  };
}