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

import {
  applyFieldsCommand,
  cloneRepeatRowCommand,
  inspectFieldsCommand,
  removeRepeatRowCommand,
} from '../../src/onlyoffice/commands';

function control(
  tag: string,
  kind: 'checkbox' | 'date' | 'multiline' | 'select' | 'text',
  initial: boolean | string,
  initialLock = 'unlocked',
  dateFormat = 'yyyy-MM-dd',
  initialTextPr: Record<string, unknown> = {},
) {
  let value = initial;
  let lock = initialLock;
  let textPr = initialTextPr;
  const setLock = vi.fn((next: string) => {
    lock = next;
    return true;
  });
  const options = [
    { GetText: () => '合格', GetValue: () => 'qualified' },
    { GetText: () => '不合格', GetValue: () => 'unqualified' },
  ];
  return {
    GetTag: () => tag,
    GetAlias: () => '字段',
    GetInternalId: () => `id-${tag}`,
    GetLock: () => lock,
    GetRange: () => {
      const range = {
        GetText: () => {
          if (typeof value === 'boolean') return value ? '☒' : '☐';
          return kind === 'multiline' && value ? `${value.replaceAll('\n', '\r\n')}\r\n` : value;
        },
        GetTextPr: () => textPr,
        SetTextPr(next: Record<string, unknown>) {
          textPr = next;
          return range;
        },
      };
      return range;
    },
    IsCheckBox: () => kind === 'checkbox',
    IsComboBox: () => kind === 'select',
    IsDropDownList: () => false,
    IsDatePicker: () => kind === 'date',
    IsBlockLevel: () => kind === 'multiline',
    GetDropdownList: () => ({ GetElementsCount: () => options.length, GetItem: (index: number) => options[index] }),
    SetCheckBoxChecked(next: boolean) {
      value = next;
      return true;
    },
    SelectListItem(next: string) {
      value = options.find((item) => item.GetValue() === next)?.GetText() ?? '';
      return true;
    },
    SetDate(next: Date) {
      const date = `${next.getFullYear()}-${String(next.getMonth() + 1).padStart(2, '0')}-${String(next.getDate()).padStart(2, '0')}`;
      value = /h/iu.test(dateFormat)
        ? `${date} ${String(next.getHours()).padStart(2, '0')}:${String(next.getMinutes()).padStart(2, '0')}:${String(next.getSeconds()).padStart(2, '0')}`
        : date;
      return true;
    },
    SetLock: setLock,
    ToJSON: () => JSON.stringify({ sdtPr: { date: { dateFormat } } }),
    RemoveAllElements() {
      value = '';
      textPr = {};
      return true;
    },
    AddElement(item: { text?: string }) {
      const text = item.text ?? '';
      value = kind === 'multiline' && value !== '' ? `${value}\n${text}` : `${value}${text}`;
      return true;
    },
  };
}

function install(controls: unknown[], changes: unknown[] = []) {
  const createParagraph = vi.fn(() => ({
    text: '',
    AddText(text: string) {
      this.text += text;
      return true;
    },
  }));
  vi.stubGlobal('Asc', { scope: { elnRecordFillInspect: {}, elnRecordFillChanges: changes } });
  vi.stubGlobal('Api', {
    GetDocument: () => ({ GetAllContentControls: () => controls }),
    CreateRun: () => ({
      text: '',
      AddText(value: string) {
        this.text = value;
        return true;
      },
    }),
    CreateParagraph: createParagraph,
  });
  return { createParagraph };
}

function serializeCommand(command: () => string): () => string {
  // The ONLYOFFICE command is intentionally re-evaluated without module scope.
  // eslint-disable-next-line no-new-func
  return new Function(`"use strict"; return (${command.toString()});`)() as () => string;
}

function installRepeatDocument(options: { failTag?: string } = {}) {
  const controls: any[] = [];
  const rows: any[] = [];
  let targetSequence = 0;
  let table: any;

  function makeControl(initialTag: string, cell: any) {
    let tag = initialTag;
    return {
      GetParentTableCell: () => cell,
      GetTag: () => tag,
      SetTag: vi.fn((next: string) => {
        if (next === options.failTag) return false;
        tag = next;
        return true;
      }),
    };
  }

  function makeRow(id: string, sourceTags: Array<null | string>) {
    const row: any = {
      GetCellsCount: () => sourceTags.length,
      GetInternalId: () => id,
      GetCell: (index: number) => row.cells[index],
      Remove: vi.fn(() => {
        const index = rows.indexOf(row);
        if (index >= 0) rows.splice(index, 1);
        for (let controlIndex = controls.length - 1; controlIndex >= 0; controlIndex -= 1) {
          if (controls[controlIndex].GetParentTableCell().GetParentRow() === row) controls.splice(controlIndex, 1);
        }
        return true;
      }),
      cells: [] as any[],
    };
    row.cells = sourceTags.map((sourceTag) => {
      const elements = sourceTag ? [{ Copy: () => ({ tag: sourceTag }) }] : [{ Copy: () => ({ tag: null }) }];
      const cell: any = {
        Cell: { SetVMerge: vi.fn() },
        AddElement: vi.fn((_index: number, element: { tag: null | string }) => {
          if (element.tag) controls.push(makeControl(element.tag, cell));
          return true;
        }),
        Clear: vi.fn(() => true),
        GetContent: () => ({ GetContent: () => elements }),
        GetParentRow: () => row,
        GetParentTable: () => table,
      };
      return cell;
    });
    return row;
  }

  const sourceTags = ['eln.repeat.results.prototype.value', 'eln.repeat.results.prototype.unit'];
  const sourceRow = makeRow('source-row', sourceTags);
  table = {
    AddRow: vi.fn((anchorCell: any, isBefore = false) => {
      targetSequence += 1;
      const target = makeRow(`target-row-${targetSequence}`, sourceTags.map(() => null));
      const anchorIndex = rows.indexOf(anchorCell.GetParentRow());
      rows.splice(anchorIndex + (isBefore ? 0 : 1), 0, target);
      return target;
    }),
    GetInternalId: () => 'table-1',
    GetRow: (index: number) => rows[index],
    GetRowsCount: () => rows.length,
  };
  rows.push(sourceRow);
  sourceTags.forEach((tag, index) => controls.push(makeControl(tag, sourceRow.GetCell(index))));
  vi.stubGlobal('Asc', { scope: { elnRecordFillRepeatRow: { groupCode: 'results', rowId: 'row-1' } } });
  vi.stubGlobal('Api', { GetDocument: () => ({ GetAllContentControls: () => controls }) });
  return { controls, rows, table };
}

// eslint-disable-next-line test/prefer-lowercase-title -- ONLYOFFICE is the product's canonical spelling.
describe('ONLYOFFICE fill commands', () => {
  afterEach(() => vi.unstubAllGlobals());

  it('inspects typed primary and reference ELN controls and ignores other tags', () => {
    install([
      control('eln.field.name', 'text', 'A'),
      control('eln.ref.name.instance_1', 'text', 'A'),
      control('eln.field.ok', 'checkbox', false),
      control('other', 'text', 'x'),
    ]);
    const result = JSON.parse(inspectFieldsCommand());
    expect(result.fields).toHaveLength(3);
    expect(result.fields[1]).toMatchObject({ tag: 'eln.ref.name.instance_1', type: 'text', currentValue: 'A' });
    expect(result.fields[2]).toMatchObject({ tag: 'eln.field.ok', type: 'checkbox', currentValue: false });
  });

  it('inspects dotted shared field codes for primary and reference controls', () => {
    install([
      control('eln.field.inspection.result', 'text', '合格'),
      control('eln.ref.inspection.result.instance_1', 'text', '合格'),
    ]);

    expect(JSON.parse(inspectFieldsCommand()).fields).toEqual([
      expect.objectContaining({ tag: 'eln.field.inspection.result', currentValue: '合格' }),
      expect.objectContaining({ tag: 'eln.ref.inspection.result.instance_1', currentValue: '合格' }),
    ]);
  });

  it('treats ONLYOFFICE placeholder text as an empty field value', () => {
    const item = control('eln.field.observation', 'text', '请输入检测观察');
    item.ToJSON = () => JSON.stringify({ sdtPr: { showingPlcHdr: true } });
    install([item]);

    expect(JSON.parse(inspectFieldsCommand()).fields).toEqual([
      expect.objectContaining({ tag: 'eln.field.observation', currentValue: '' }),
    ]);
  });

  it('inspects fields after ONLYOFFICE serializes the command without module closures', () => {
    install([control('eln.field.name', 'text', 'A')]);

    expect(JSON.parse(serializeCommand(inspectFieldsCommand)())).toMatchObject({
      ok: true,
      fields: [{ tag: 'eln.field.name', type: 'text', currentValue: 'A' }],
    });
  });

  it('keeps a datetime control format when inspecting fields', () => {
    install([control('eln.field.tested_at', 'date', '2026-08-13 09:10:11', 'unlocked', 'yyyy-MM-dd HH:mm:ss')]);

    expect(JSON.parse(inspectFieldsCommand()).fields).toEqual([
      expect.objectContaining({ dateFormat: 'yyyy-MM-dd HH:mm:ss', tag: 'eln.field.tested_at', type: 'date' }),
    ]);
  });

  it('preserves Chinese date formats and applies canonical datetime values', () => {
    const item = control('eln.field.tested_at', 'date', '', 'unlocked', 'yyyy年MM月dd日 HH:mm:ss');
    install([item], [{ tag: 'eln.field.tested_at', type: 'date', value: '2026-09-05 14:30:25' }]);

    expect(JSON.parse(inspectFieldsCommand()).fields).toEqual([
      expect.objectContaining({ dateFormat: 'yyyy年MM月dd日 HH:mm:ss', tag: 'eln.field.tested_at', type: 'date' }),
    ]);
    expect(JSON.parse(applyFieldsCommand()).results).toEqual([{ tag: 'eln.field.tested_at', ok: true }]);
  });

  it('recognizes a block control from JSON when ONLYOFFICE reports IsBlockLevel as false', () => {
    const item = control('eln.field.result', 'text', '检验结果');
    item.ToJSON = () => JSON.stringify({ sdtPr: {}, type: 'blockLvlSdt' });
    install([item]);

    expect(JSON.parse(inspectFieldsCommand()).fields).toEqual([
      expect.objectContaining({ tag: 'eln.field.result', type: 'multiline' }),
    ]);
  });

  it('applies text, checkbox, select and date values', () => {
    const controls = [
      control('eln.field.name', 'text', ''),
      control('eln.field.ok', 'checkbox', false),
      control('eln.field.result', 'select', '合格'),
      control('eln.field.date', 'date', '2026-08-12'),
    ];
    install(controls, [
      { tag: 'eln.field.name', type: 'text', value: '样品' },
      { tag: 'eln.field.ok', type: 'checkbox', value: true },
      { tag: 'eln.field.result', type: 'select', value: 'unqualified' },
      { tag: 'eln.field.date', type: 'date', value: '2026-08-13' },
    ]);
    expect(JSON.parse(applyFieldsCommand()).results).toEqual([
      { tag: 'eln.field.name', ok: true },
      { tag: 'eln.field.ok', ok: true },
      { tag: 'eln.field.result', ok: true },
      { tag: 'eln.field.date', ok: true },
    ]);
  });

  it.each([
    { kind: 'text', value: '样品' },
    { kind: 'multiline', value: '第一行\n第二行' },
    { kind: 'checkbox', value: true },
    { kind: 'select', value: 'unqualified' },
    { kind: 'date', value: '2026-08-13' },
  ] as const)('填写 $kind 控件后保留原字符格式', ({ kind, value }) => {
    const textPr = { fontFamily: 'SimSun', fontSize: 14, underline: true };
    const item = control(`eln.field.${kind}`, kind, '', 'unlocked', 'yyyy-MM-dd', textPr);
    install([item], [{ tag: `eln.field.${kind}`, type: kind, value }]);

    expect(JSON.parse(applyFieldsCommand()).results).toEqual([{ tag: `eln.field.${kind}`, ok: true }]);
    expect(item.GetRange().GetTextPr()).toEqual(textPr);
  });

  it('applies datetime values without dropping the time component', () => {
    const item = control('eln.field.tested_at', 'date', '2026-08-12 01:02:03', 'unlocked', 'yyyy-MM-dd HH:mm:ss');
    install([item], [{ tag: 'eln.field.tested_at', type: 'date', value: '2026-08-13 09:10:11' }]);

    expect(JSON.parse(applyFieldsCommand()).results).toEqual([{ tag: 'eln.field.tested_at', ok: true }]);
    expect(item.GetRange().GetText()).toBe('2026-08-13 09:10:11');
  });

  it.each([
    { kind: 'select', initial: '合格', format: 'yyyy-MM-dd' },
    { kind: 'date', initial: '2026-08-13', format: 'yyyy-MM-dd' },
    { kind: 'date', initial: '2026-08-13 09:10:11', format: 'yyyy-MM-dd HH:mm:ss' },
  ] as const)('clears $kind ($format) without replacing its definition or lock', ({ kind, initial, format }) => {
    const tag = 'eln.field.source';
    const textPr = { fontFamily: 'SimSun', fontSize: 14 };
    const item = control(tag, kind, initial, 'sdtContentLocked', format, textPr);
    install([item], [{ tag, type: kind, value: '' }]);
    const before = JSON.parse(serializeCommand(inspectFieldsCommand)()).fields[0];

    expect(JSON.parse(serializeCommand(applyFieldsCommand)()).results).toEqual([{ tag, ok: true }]);
    const after = JSON.parse(serializeCommand(inspectFieldsCommand)()).fields[0];
    expect(after).toEqual({ ...before, currentValue: '' });
    expect(item.GetLock()).toBe('sdtContentLocked');
    expect(item.GetRange().GetTextPr()).toEqual(textPr);
  });

  it('applies fields after ONLYOFFICE serializes the command without module closures', () => {
    const item = control('eln.field.name', 'text', '');
    install([item], [{ tag: 'eln.field.name', type: 'text', value: '样品' }]);

    expect(JSON.parse(serializeCommand(applyFieldsCommand)()).results).toEqual([{ tag: 'eln.field.name', ok: true }]);
    expect(item.GetRange().GetText()).toBe('样品');
  });

  it('applies synchronized data to a reference control without treating it as an independent value', () => {
    const item = control('eln.ref.name.instance_1', 'text', 'old');
    install([item], [{ tag: 'eln.ref.name.instance_1', type: 'text', value: '同步值' }]);

    expect(JSON.parse(applyFieldsCommand()).results).toEqual([{ tag: 'eln.ref.name.instance_1', ok: true }]);
    expect(item.GetRange().GetText()).toBe('同步值');
  });

  it('restores a locked reference control after synchronizing it', () => {
    const item = control('eln.ref.name.instance_1', 'text', 'old', 'contentLocked');
    install([item], [{ tag: 'eln.ref.name.instance_1', type: 'text', value: '同步值' }]);

    expect(JSON.parse(applyFieldsCommand()).results).toEqual([{ tag: 'eln.ref.name.instance_1', ok: true }]);
    expect(item.GetRange().GetText()).toBe('同步值');
    expect(item.GetLock()).toBe('contentLocked');
    expect(item.SetLock).toHaveBeenNthCalledWith(1, 'unlocked');
    expect(item.SetLock).toHaveBeenNthCalledWith(2, 'contentLocked');
  });

  it('temporarily unlocks formula result primary and reference controls while restoring current data', () => {
    const primary = control('eln.field.formula_result', 'text', 'old-primary', 'sdtContentLocked');
    const reference = control('eln.ref.formula_result.instance_1', 'text', 'old-reference', 'sdtContentLocked');
    install([primary, reference], [
      { tag: 'eln.field.formula_result', type: 'text', value: '42' },
      { tag: 'eln.ref.formula_result.instance_1', type: 'text', value: '42' },
    ]);

    expect(JSON.parse(applyFieldsCommand()).results).toEqual([
      { tag: 'eln.field.formula_result', ok: true },
      { tag: 'eln.ref.formula_result.instance_1', ok: true },
    ]);
    for (const item of [primary, reference]) {
      expect(item.GetRange().GetText()).toBe('42');
      expect(item.GetLock()).toBe('sdtContentLocked');
      expect(item.SetLock).toHaveBeenNthCalledWith(1, 'unlocked');
      expect(item.SetLock).toHaveBeenNthCalledWith(2, 'sdtContentLocked');
    }
  });

  it('rejects unknown select values without changing the field', () => {
    const item = control('eln.field.result', 'select', '合格');
    install([item], [{ tag: 'eln.field.result', type: 'select', value: 'missing' }]);
    const result = JSON.parse(applyFieldsCommand()).results[0];
    expect(result).toMatchObject({ tag: 'eln.field.result', ok: false, error: '下拉值不在文档选项中' });
    expect(item.GetRange().GetText()).toBe('合格');
  });

  it('writes multiline values as one paragraph per line', () => {
    const item = control('eln.field.notes', 'multiline', '');
    const { createParagraph } = install([item], [{ tag: 'eln.field.notes', type: 'multiline', value: '第一行\n第二行' }]);

    expect(JSON.parse(applyFieldsCommand()).results).toEqual([{ tag: 'eln.field.notes', ok: true }]);
    expect(createParagraph).toHaveBeenCalledTimes(2);
    expect(item.GetRange().GetText()).toBe('第一行\r\n第二行\r\n');
  });

  it('continues applying later fields after one field fails', () => {
    const select = control('eln.field.result', 'select', '合格');
    const text = control('eln.field.name', 'text', '');
    install(
      [select, text],
      [
        { tag: 'eln.field.result', type: 'select', value: 'missing' },
        { tag: 'eln.field.name', type: 'text', value: '样品' },
      ],
    );

    expect(JSON.parse(applyFieldsCommand()).results).toEqual([
      { tag: 'eln.field.result', ok: false, error: '下拉值不在文档选项中' },
      { tag: 'eln.field.name', ok: true },
    ]);
    expect(text.GetRange().GetText()).toBe('样品');
  });

  it('clones the prototype row at the table end and rewrites every repeat tag', () => {
    const { controls, rows, table } = installRepeatDocument();

    const result = JSON.parse(serializeCommand(cloneRepeatRowCommand)());

    expect(result).toEqual({
      ok: true,
      tags: ['eln.repeat.results.row-1.value', 'eln.repeat.results.row-1.unit'],
    });
    expect(table.AddRow).toHaveBeenCalledTimes(1);
    expect(table.AddRow).toHaveBeenCalledWith(expect.anything(), false);
    expect(rows).toHaveLength(2);
    expect(rows[1].GetCell(0).Clear).toHaveBeenCalledTimes(1);
    expect(rows[1].GetCell(1).Clear).not.toHaveBeenCalled();
    expect(rows[1].GetCell(0).Cell.SetVMerge).toHaveBeenCalledWith(undefined);
    expect(rows[1].GetCell(1).Cell.SetVMerge).toHaveBeenCalledWith(undefined);
    expect(controls.map((item) => item.GetTag())).toEqual([
      'eln.repeat.results.prototype.value',
      'eln.repeat.results.prototype.unit',
      'eln.repeat.results.row-1.value',
      'eln.repeat.results.row-1.unit',
    ]);

    expect(JSON.parse(cloneRepeatRowCommand())).toMatchObject({ ok: true });
    expect(table.AddRow).toHaveBeenCalledTimes(1);
  });

  it('removes the appended row when tag rewriting fails', () => {
    const { controls, rows } = installRepeatDocument({ failTag: 'eln.repeat.results.row-1.unit' });

    expect(JSON.parse(cloneRepeatRowCommand())).toMatchObject({ ok: false, error: '重写重复行 Tag 失败' });
    expect(rows).toHaveLength(1);
    expect(controls.map((item) => item.GetTag())).toEqual([
      'eln.repeat.results.prototype.value',
      'eln.repeat.results.prototype.unit',
    ]);
  });

  it('removes exactly one complete runtime row by stable group and row identity', () => {
    const { controls, rows } = installRepeatDocument();
    expect(JSON.parse(cloneRepeatRowCommand())).toMatchObject({ ok: true });
    (globalThis as any).Asc.scope.elnRecordFillRepeatRow = { groupCode: 'results', rowId: 'row-1' };

    const result = JSON.parse(serializeCommand(removeRepeatRowCommand)());

    expect(result).toEqual({
      ok: true,
      tags: ['eln.repeat.results.row-1.value', 'eln.repeat.results.row-1.unit'],
    });
    expect(rows).toHaveLength(1);
    expect(controls.map((item) => item.GetTag())).toEqual([
      'eln.repeat.results.prototype.value',
      'eln.repeat.results.prototype.unit',
    ]);
  });

  it('recreates a removed row before the next logical runtime row', () => {
    const { controls, rows } = installRepeatDocument();
    expect(JSON.parse(cloneRepeatRowCommand())).toMatchObject({ ok: true });
    (globalThis as any).Asc.scope.elnRecordFillRepeatRow = { groupCode: 'results', rowId: 'row-2' };
    expect(JSON.parse(cloneRepeatRowCommand())).toMatchObject({ ok: true });
    (globalThis as any).Asc.scope.elnRecordFillRepeatRow = { groupCode: 'results', rowId: 'row-1' };
    expect(JSON.parse(removeRepeatRowCommand())).toMatchObject({ ok: true });
    (globalThis as any).Asc.scope.elnRecordFillRepeatRow = {
      beforeRowId: 'row-2', groupCode: 'results', rowId: 'row-1',
    };

    expect(JSON.parse(serializeCommand(cloneRepeatRowCommand)())).toMatchObject({ ok: true });
    expect(rows).toHaveLength(3);
    expect(controls.filter((item) => item.GetTag().startsWith('eln.repeat.results.row-1.'))[0]
      .GetParentTableCell().GetParentRow()).toBe(rows[1]);
    expect(controls.filter((item) => item.GetTag().startsWith('eln.repeat.results.row-2.'))[0]
      .GetParentTableCell().GetParentRow()).toBe(rows[2]);
  });
});