/* eslint-disable vue/one-component-per-file -- 测试中分别模拟弹窗容器和表单解析器。 */
import { flushPromises, mount } from '@vue/test-utils';

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

import FormPopup from './FormPopup.vue';

const mocks = vi.hoisted(() => ({
  capture: vi.fn(),
  confirm: vi.fn(),
  createModel: vi.fn(),
  customFormInit: vi.fn(),
  error: vi.fn(),
  getDataInterfaceRes: vi.fn(),
  getLaunchFlowParamList: vi.fn(),
  getParamList: vi.fn(),
  init: undefined as ((data: any) => void) | undefined,
  launchFlow: vi.fn(),
  reset: vi.fn(),
  runtime: {} as any,
  selectedRows: vi.fn(),
  sign: vi.fn(),
  signedUtils: vi.fn(),
  submit: vi.fn(),
  validate: vi.fn(),
  warning: vi.fn(),
}));

vi.mock('@jnpf/hooks', () => ({
  useMessage: () => ({ createConfirm: mocks.confirm, createMessage: { error: mocks.error, success: vi.fn(), warning: mocks.warning } }),
}));
vi.mock('@vben/stores', () => ({ useUserStore: () => ({ getUserInfo: {} }) }));
vi.mock('#/api/onlineDev/visualDev', () => ({ createModel: mocks.createModel, launchFlow: mocks.launchFlow }));
vi.mock('#/api/systemData/dataInterface', () => ({ getDataInterfaceRes: mocks.getDataInterfaceRes }));
vi.mock('#/api/onlineDev/auditHeaders', () => ({ createAuditCorrelationId: () => 'audit-id' }));
vi.mock('#/locales', () => ({ $t: (value: string, fallback?: string) => fallback || value }));
vi.mock('#/utils/jnpf', () => ({
  getLaunchFlowParamList: mocks.getLaunchFlowParamList,
  getParamList: mocks.getParamList,
  onlineUtils: { capture: mocks.capture, sign: mocks.sign },
}));
vi.mock('#/components/FormGenerator/src/helper/auditDisplay', () => ({
  createAuditRequestOnlineUtils: (utils: any) => utils,
  createSignedAuditRequestOnlineUtils: mocks.signedUtils,
}));
vi.mock('../list/CustomForm.vue', async () => {
  const { defineComponent, h } = await import('vue');
  return {
    default: defineComponent({
      setup(_, { expose }) {
        expose({ init: mocks.customFormInit });
        return () => h('div');
      },
    }),
  };
});
vi.mock('@jnpf/ui/popup', async () => {
  const { defineComponent, h } = await import('vue');
  return {
    BasicPopup: defineComponent({
      setup:
        (_, { slots }) =>
        () =>
          h('div', [h('header', slots.insertToolbar?.()), slots.default?.()]),
    }),
    usePopupInner: (init: (data: any) => void) => {
      mocks.init = init;
      return [vi.fn(), { changeLoading: vi.fn(), setPopupProps: vi.fn() }];
    },
  };
});
vi.mock('@jnpf/utils', async () => {
  const { defineComponent, h, inject } = await import('vue');
  const { getScriptFunc } = await import('../../../../../../../packages/jnpf/utils/src/helpers/common');
  return {
    createAsyncComponent: () =>
      defineComponent({
        name: 'ParserStub',
        emits: ['runtimeChange', 'submit'],
        setup(_, { expose }) {
          const onlineUtils = inject('onlineUtils');
          expose({
            getRuntimeParameter: () => ({ ...mocks.runtime, getTableSelectedRows: mocks.selectedRows, onlineUtils }),
            handleReset: mocks.reset,
            handleSubmit: mocks.submit,
            handleValidate: mocks.validate,
          });
          return () => h('div');
        },
      }),
    getDateTimeUnit: () => 'day',
    getScriptFunc,
  };
});

describe('pure form toolbar and save', () => {
  let wrapper: ReturnType<typeof mount>;

  beforeEach(() => {
    vi.resetAllMocks();
    mocks.runtime = { formData: { id: '', status: 'ready' } };
    mocks.selectedRows.mockReturnValue([]);
    mocks.validate.mockResolvedValue(true);
    mocks.getDataInterfaceRes.mockResolvedValue({ msg: 'done' });
    mocks.launchFlow.mockResolvedValue({ msg: 'done' });
    mocks.signedUtils.mockImplementation((utils, getSign) => ({ ...utils, credential: getSign() }));
  });

  afterEach(() => {
    wrapper?.unmount();
    wrapper = undefined as any;
  });

  async function open(customSubmit = false, config: any = {}, isPreview = false) {
    if (!wrapper) wrapper = mount(FormPopup, { global: { stubs: { AButton: { template: '<button><slot /></button>' } } } });
    mocks.init?.({
      modelId: 'model',
      isPreview,
      formData: JSON.stringify({
        fields: [],
        funcs: { customSubmit, customSubmitFunc: '({ formContext }) => new Promise((resolve, reject) => formContext.submit(resolve, reject))' },
        ...config,
      }),
    });
    await flushPromises();
  }

  function customButton(actionConfig: any = {}, extra: any = {}) {
    return {
      value: 'action',
      label: '业务操作',
      show: true,
      actionConfig: { btnType: 2, func: '({ onlineUtils }) => onlineUtils.capture()', ...actionConfig },
      ...extra,
    };
  }

  async function click(label = '业务操作') {
    const button = wrapper.findAll('button').find((item) => item.text() === label);
    expect(button, `button ${label}`).toBeDefined();
    await button!.trigger('click');
    await flushPromises();
  }

  it.each([undefined, true, false])('hides confirm only for explicit false (%s)', async (hasConfirmBtn) => {
    await open(false, { hasConfirmBtn });
    expect(wrapper.findAll('button').some((button) => button.text() === 'common.okText')).toBe(hasConfirmBtn !== false);
    expect(wrapper.findAll('button').some((button) => button.text() === 'common.resetText')).toBe(true);
    if (hasConfirmBtn !== false) {
      await click('common.okText');
      expect(mocks.submit).toHaveBeenCalledOnce();
    }
  });

  it('runs a button with latest selected tuples without validating or submitting the scan form', async () => {
    await open(false, {
      hasConfirmBtn: false,
      formCustomBtns: [
        customButton({
          enableFormValidate: false,
          func: '({ formData, data, getTableSelectedRows, onlineUtils }) => onlineUtils.capture(formData, data, getTableSelectedRows("items"))',
        }),
      ],
    });
    mocks.runtime.formData = { id: '', status: 'changed' };
    const rows = [[2, { wenjian_id: 'doc-2' }]];
    mocks.selectedRows.mockReturnValue(rows);
    await click();
    expect(mocks.capture).toHaveBeenCalledExactlyOnceWith(mocks.runtime.formData, mocks.runtime.formData, rows);
    expect(mocks.selectedRows).toHaveBeenCalledWith('items');
    expect(mocks.validate).not.toHaveBeenCalled();
    expect(mocks.submit).not.toHaveBeenCalled();
    expect(mocks.createModel).not.toHaveBeenCalled();
    expect(mocks.reset).not.toHaveBeenCalled();
  });

  it('updates enable rules when runtime data changes and omits hidden buttons', async () => {
    await open(false, {
      formCustomBtns: [
        customButton({ enableFunc: '({ data }) => data.status === "ready"' }),
        customButton({}, { value: 'hidden', label: '隐藏按钮', show: false }),
      ],
    });
    expect(wrapper.text()).toContain('业务操作');
    expect(wrapper.text()).not.toContain('隐藏按钮');
    mocks.runtime.formData.status = 'blocked';
    wrapper.findComponent({ name: 'ParserStub' }).vm.$emit('runtimeChange');
    await flushPromises();
    expect(wrapper.text()).not.toContain('业务操作');
  });

  it.each([true, false])('validates by default and executes only on success (%s)', async (valid) => {
    mocks.validate.mockResolvedValue(valid);
    await open(false, { formCustomBtns: [customButton()] });
    await click();
    expect(mocks.validate).toHaveBeenCalledOnce();
    expect(mocks.capture).toHaveBeenCalledTimes(valid ? 1 : 0);
    expect(mocks.createModel).not.toHaveBeenCalled();
  });

  it('discards an old action when the form is reopened during validation', async () => {
    let resolveValidate!: (value: boolean) => void;
    mocks.validate.mockReturnValue(new Promise((resolve) => (resolveValidate = resolve)));
    await open(false, { formCustomBtns: [customButton()] });
    await click();
    await open(false);
    resolveValidate(true);
    await flushPromises();
    expect(mocks.capture).not.toHaveBeenCalled();
  });

  it('lets scripts validate before explicitly requesting a signature', async () => {
    await open(false, {
      formCustomBtns: [
        customButton({
          biz_sign_enabled: true,
          func: '({ formData, sign }) => { if (formData.status !== "ready") return; return sign(({ bizSign, onlineUtils }) => onlineUtils.capture(bizSign, onlineUtils.credential)); }',
        }),
      ],
    });
    mocks.runtime.formData.status = 'blocked';
    await click();
    expect(mocks.sign).not.toHaveBeenCalled();
    mocks.runtime.formData.status = 'ready';
    await click();
    expect(mocks.sign).toHaveBeenCalledOnce();
    expect(mocks.capture).not.toHaveBeenCalled();
    const options = mocks.sign.mock.calls[0]![0];
    expect(options.metaData).toMatchObject({ biz_form_id: 'model', biz_button: '业务操作', biz_data: [mocks.runtime.formData] });
    options.onCancel();
    expect(mocks.capture).not.toHaveBeenCalled();
    options.onSubmit({ biz_sign: 'sign-id' });
    expect(mocks.capture).toHaveBeenCalledExactlyOnceWith('sign-id', 'sign-id');
  });

  it('does not run a pending signed callback after reset', async () => {
    await open(false, { formCustomBtns: [customButton({ biz_sign_enabled: true, func: '({ sign }) => sign(({ onlineUtils }) => onlineUtils.capture())' })] });
    await click();
    const options = mocks.sign.mock.calls[0]![0];
    await click('common.resetText');
    options.onSubmit({ biz_sign: 'old-sign' });
    expect(mocks.capture).not.toHaveBeenCalled();
  });

  it('calls sign callbacks directly when electronic signing is disabled', async () => {
    await open(false, { formCustomBtns: [customButton({ func: '({ sign }) => sign(({ bizSign, onlineUtils }) => onlineUtils.capture(bizSign))' })] });
    await click();
    expect(mocks.capture).toHaveBeenCalledExactlyOnceWith(undefined);
    expect(mocks.sign).not.toHaveBeenCalled();
  });

  it('opens an associated form with the current record', async () => {
    await open(false, { formCustomBtns: [customButton({ btnType: 1, modelId: 'target' })] });
    await click();
    expect(mocks.customFormInit).toHaveBeenCalledWith(expect.objectContaining({ menuId: 'target', record: mocks.runtime.formData, recordModelId: 'model' }));
    expect(mocks.createModel).not.toHaveBeenCalled();
  });

  it('runs an interface only after its signature and confirmation', async () => {
    mocks.getParamList.mockReturnValue([{ field: 'status', defaultValue: 'ready' }]);
    await open(false, { formCustomBtns: [customButton({ btnType: 3, interfaceId: 'interface', templateJson: [], useConfirm: true, biz_sign_enabled: true })] });
    await click();
    expect(mocks.confirm).not.toHaveBeenCalled();
    mocks.sign.mock.calls[0]![0].onSubmit({ biz_sign: 'sign-id' });
    expect(mocks.confirm).toHaveBeenCalledOnce();
    expect(mocks.getDataInterfaceRes).not.toHaveBeenCalled();
    await mocks.confirm.mock.calls[0]![0].onOk();
    expect(mocks.getParamList).toHaveBeenCalledWith([], mocks.runtime.formData);
    expect(mocks.getDataInterfaceRes).toHaveBeenCalledExactlyOnceWith('interface', { paramList: [{ field: 'status', defaultValue: 'ready' }] });
  });

  it('launches a configured flow with mapped form data', async () => {
    mocks.getLaunchFlowParamList.mockReturnValue({ status: 'ready' });
    await open(false, { formCustomBtns: [customButton({ btnType: 4, launchFlow: { flowId: 'flow', transferList: [], currentUser: true } })] });
    await click();
    expect(mocks.getLaunchFlowParamList).toHaveBeenCalledWith([], mocks.runtime.formData);
    expect(mocks.launchFlow).toHaveBeenCalledWith('model', expect.objectContaining({ template: 'flow', btnCode: 'action', dataList: [{ status: 'ready' }] }));
  });

  it('prevents custom actions in preview', async () => {
    await open(false, { formCustomBtns: [customButton()] }, true);
    await click();
    expect(mocks.warning).toHaveBeenCalled();
    expect(mocks.validate).not.toHaveBeenCalled();
    expect(mocks.capture).not.toHaveBeenCalled();
  });

  it('reports rejected script promises without saving the form', async () => {
    await open(false, { formCustomBtns: [customButton({ func: '() => Promise.reject(new Error("业务失败"))' })] });
    await click();
    expect(mocks.error).toHaveBeenCalledWith('业务失败');
    expect(mocks.createModel).not.toHaveBeenCalled();
  });

  it.each([false, true])('passes the saved ID before resetting (customSubmit=%s)', async (customSubmit) => {
    await open(customSubmit);
    let resolveSave!: (response: any) => void;
    mocks.createModel.mockReturnValue(new Promise((resolve) => (resolveSave = resolve)));
    const callback = vi.fn(() => expect(mocks.reset).not.toHaveBeenCalled());
    wrapper.findComponent({ name: 'ParserStub' }).vm.$emit('submit', { id: '', name: 'new' }, callback);
    await flushPromises();
    expect(callback).not.toHaveBeenCalled();

    resolveSave({ data: { id: 'saved-id' }, msg: 'saved' });
    await flushPromises();
    expect(callback).toHaveBeenCalledExactlyOnceWith('saved-id');
    expect(mocks.reset).toHaveBeenCalledOnce();
  });

  it.each([false, true])('does not call afterSubmit or reset on failed save (customSubmit=%s)', async (customSubmit) => {
    await open(customSubmit);
    mocks.createModel.mockRejectedValue(new Error('save failed'));
    const callback = vi.fn();
    wrapper.findComponent({ name: 'ParserStub' }).vm.$emit('submit', { name: 'new' }, callback);
    await flushPromises();
    expect(callback).not.toHaveBeenCalled();
    expect(mocks.reset).not.toHaveBeenCalled();
  });
});