/* eslint-disable vue/one-component-per-file, vue/require-default-prop -- Test doubles intentionally stay local to this component suite. */
import type { DmsPersonalFolderFile } from '#/api/x/dms/personalFolder';

import { mount } from '@vue/test-utils';
import { defineComponent, h, nextTick } from 'vue';

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

import PersonalFolderPage from '../index.vue';
import pageSource from '../index.vue?raw';

const apiMocks = vi.hoisted(() => ({
  createDmsFileDownloadTicket: vi.fn(),
  downloadDmsFile: vi.fn(),
  evaluatePersonalFolderDownloads: vi.fn(),
  getPersonalFolderFiles: vi.fn(),
  getPersonalFolders: vi.fn(),
}));
const messageMocks = vi.hoisted(() => ({ error: vi.fn(), success: vi.fn() }));
const previewMocks = vi.hoisted(() => ({ open: vi.fn() }));
const utilityMocks = vi.hoisted(() => ({ downloadByData: vi.fn() }));
const formState = vi.hoisted(() => ({ config: undefined as any, setFieldsValue: vi.fn() }));
const tableState = vi.hoisted(() => ({ config: undefined as any }));
const treeState = vi.hoisted(() => ({ setSelectedKeys: vi.fn() }));

vi.mock('#/api/x/dms/personalFolder', () => ({
  createDmsFileDownloadTicket: apiMocks.createDmsFileDownloadTicket,
  downloadDmsFile: apiMocks.downloadDmsFile,
  evaluatePersonalFolderDownloads: apiMocks.evaluatePersonalFolderDownloads,
  getPersonalFolderFiles: apiMocks.getPersonalFolderFiles,
  getPersonalFolders: apiMocks.getPersonalFolders,
}));

vi.mock('#/utils/jnpf', () => ({
  getJnpfAppEnCode: () => '',
  onlineUtils: { hideLoading: vi.fn(), showLoading: vi.fn() },
}));

vi.mock('../../shared/dmsFilePreview', () => ({
  dmsPreviewErrorMessage: (error: unknown) => (error instanceof Error ? error.message : '文件预览失败'),
  openDmsFilePreview: previewMocks.open,
}));

vi.mock('@jnpf/hooks', () => ({
  useMessage: () => ({ createMessage: messageMocks }),
}));

vi.mock('@jnpf/utils', () => ({
  downloadByData: utilityMocks.downloadByData,
  formatToDateTime: (value: string, format?: string) => `${format || 'datetime'}:${value}`,
}));

vi.mock('@jnpf/ui', async () => {
  const { defineComponent, h } = await import('vue');
  return {
    BasicLeftTree: defineComponent({
      name: 'BasicLeftTree',
      props: {
        fieldNames: { default: () => ({}), type: Object },
        loading: Boolean,
        showSearch: Boolean,
        showToolbar: Boolean,
        title: String,
        treeData: { default: () => [], type: Array },
      },
      emits: ['reload', 'select'],
      setup(props, { expose, slots }) {
        expose({ setSelectedKeys: treeState.setSelectedKeys });
        return () =>
          h('aside', { 'data-test': 'folder-tree' }, [JSON.stringify(props.treeData), slots.title?.({ key: '__personal_root__', title: '个人文件夹' })]);
      },
    }),
    ScrollContainer: defineComponent({
      name: 'ScrollContainer',
      setup(_, { slots }) {
        return () => h('div', { 'data-test': 'tile-scroll' }, slots.default?.());
      },
    }),
  };
});

vi.mock('@jnpf/ui/modal', async () => {
  const { defineComponent, h } = await import('vue');
  return {
    BasicModal: defineComponent({
      name: 'BasicModal',
      emits: ['register', 'ok'],
      setup(_, { slots }) {
        return () => h('div', slots.default?.());
      },
    }),
    useModal: () => [vi.fn(), { openModal: vi.fn(), closeModal: vi.fn(), setModalProps: vi.fn() }],
  };
});

vi.mock('@jnpf/ui/form', async () => {
  const { defineComponent, h } = await import('vue');
  return {
    BasicForm: defineComponent({
      name: 'BasicForm',
      emits: ['register', 'reset', 'submit'],
      setup() {
        return () => h('form', { 'data-test': 'search-form' });
      },
    }),
    useForm: (config: any) => {
      formState.config = config;
      return [vi.fn(), { setFieldsValue: formState.setFieldsValue }];
    },
  };
});

vi.mock('@jnpf/ui/vxeTable', async () => {
  const { defineComponent, h } = await import('vue');
  return {
    BasicVxeTable: defineComponent({
      name: 'BasicVxeTable',
      inheritAttrs: false,
      props: {
        dataSource: { default: () => [], type: Array },
        emptyText: String,
        loading: Boolean,
        rowConfig: Object,
      },
      emits: ['cell-dblclick', 'register', 'row-click'],
      setup(props, { slots }) {
        return () =>
          h(
            'div',
            { 'data-test': 'personal-file-table' },
            (props.dataSource as DmsPersonalFolderFile[]).flatMap((record) => [
              slots.fileName?.({ record }),
              slots.documentNo?.({ record }),
              slots.versionLabel?.({ record }),
              slots.createdAt?.({ record }),
              slots.validTo?.({ record }),
              slots.sizeBytes?.({ record }),
              slots.action?.({ record }),
            ]),
          );
      },
    }),
    TableAction: defineComponent({
      name: 'TableAction',
      props: { actions: { default: () => [], type: Array }, stopButtonPropagation: Boolean },
      setup(props) {
        return () => h('div', { 'data-actions': (props.actions as any[]).map((action) => action.label).join(','), 'data-test': 'table-action' });
      },
    }),
    useVxeTable: (config: any) => {
      tableState.config = config;
      return [vi.fn(), {}];
    },
  };
});

vi.mock('ant-design-vue', async () => {
  const { defineComponent, h } = await import('vue');
  return {
    Radio: defineComponent({
      name: 'AntRadio',
      setup(_, { slots }) {
        return () => h('span', slots.default?.());
      },
    }),
    RadioGroup: defineComponent({
      name: 'RadioGroup',
      props: { value: String },
      emits: ['update:value'],
      setup(_, { slots }) {
        return () => h('div', slots.default?.());
      },
    }),
    Breadcrumb: defineComponent({
      name: 'AntBreadcrumb',
      setup(_, { slots }) {
        return () => h('nav', slots.default?.());
      },
    }),
    BreadcrumbItem: defineComponent({
      name: 'BreadcrumbItem',
      setup(_, { slots }) {
        return () => h('span', slots.default?.());
      },
    }),
  };
});

const ButtonStub = defineComponent({
  name: 'AButton',
  inheritAttrs: false,
  props: { loading: Boolean, type: String },
  emits: ['click'],
  setup(_, { attrs, emit, slots }) {
    return () => h('button', { ...attrs, onClick: () => emit('click'), type: 'button' }, slots.default?.());
  },
});

const SlotStub = defineComponent({
  setup(_, { slots }) {
    return () => h('div', slots.default?.());
  },
});

function file(values: Partial<DmsPersonalFolderFile> = {}): DmsPersonalFolderFile {
  return {
    createdAt: '2026-09-01T00:00:00Z',
    documentNo: 'DOC-001',
    fileName: '质量标准.pdf',
    id: 'file-1',
    name: '质量标准',
    resourceType: 'FILE_VERSION',
    sizeBytes: 1536,
    sourceId: 'source-1',
    sourceType: 'DMS',
    versionLabel: 'R01',
    ...values,
  };
}

function mountPage() {
  return mount(PersonalFolderPage, {
    global: {
      directives: { loading: () => {} },
      stubs: {
        'a-button': ButtonStub,
        'a-button-group': SlotStub,
        'a-tooltip': SlotStub,
        FileViewModeSwitch: defineComponent({
          name: 'FileViewModeSwitch',
          props: { value: String },
          emits: ['update:value'],
          setup() {
            return () => h('div');
          },
        }),
        'jnpf-empty': defineComponent({ name: 'JnpfEmpty', props: { description: String }, template: '<div data-test="empty">{{ description }}</div>' }),
      },
    },
  });
}

describe('dms personal folder page', () => {
  beforeEach(() => {
    vi.clearAllMocks();
    formState.config = undefined;
    tableState.config = undefined;
    formState.setFieldsValue.mockResolvedValue(undefined);
    apiMocks.getPersonalFolders.mockResolvedValue({
      data: [
        { code: 'BORROW', name: '借阅' },
        { code: 'DOWNLOAD', name: '下载' },
        { code: 'FAVORITE', name: '收藏' },
      ],
    });
    apiMocks.getPersonalFolderFiles.mockImplementation(async (folderType: string) => ({
      data: [file({ fileName: `${folderType}.pdf`, id: `${folderType}-file` })],
    }));
    apiMocks.evaluatePersonalFolderDownloads.mockImplementation(async (ids: string[]) => ({
      data: ids.map((resourceId) => ({ allowed: true, resourceId })),
    }));
    apiMocks.createDmsFileDownloadTicket.mockResolvedValue({
      data: { accessTicket: 'ticket-1', fileName: 'DOWNLOAD.pdf', fileVersionId: 'DOWNLOAD-file', mimeType: 'application/pdf' },
    });
    apiMocks.downloadDmsFile.mockResolvedValue(new Blob(['pdf'], { type: 'application/pdf' }));
    previewMocks.open.mockResolvedValue(true);
  });

  it('uses the standard JNPF page, tree, form and table without fake pagination', async () => {
    const wrapper = mountPage();

    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledWith('BORROW', { keyword: undefined, pageSize: 100 }));

    expect(pageSource).toContain('class="jnpf-content-wrapper personal-folder-page"');
    expect(pageSource).toContain('<BasicLeftTree');
    expect(pageSource).toContain('<BasicForm');
    expect(pageSource).toContain('<BasicVxeTable');
    expect(pageSource).toContain('<TableAction');
    expect(pageSource).not.toContain('<ATree');
    expect(pageSource).not.toContain('class="detail-list"');
    expect(tableState.config).toMatchObject({ immediate: false, pagination: false, rowKey: 'id', showIndexColumn: false });
    expect(tableState.config.columns.map((column: any) => column.title)).toEqual(['标题', '文件编号', '版本号', '上传日期', '有效期至', '文件大小']);

    const tree = wrapper.findComponent({ name: 'BasicLeftTree' });
    expect(tree.props()).toMatchObject({
      fieldNames: { children: 'children', key: 'key', title: 'title' },
      showSearch: false,
      showToolbar: true,
      title: '个人文件夹',
    });
    expect(treeState.setSelectedKeys).toHaveBeenCalledWith(['BORROW']);
  });

  it('submits trimmed search text and clears it once before changing folders', async () => {
    const wrapper = mountPage();
    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledOnce());
    apiMocks.getPersonalFolderFiles.mockClear();

    wrapper.findComponent({ name: 'BasicForm' }).vm.$emit('submit', { keyword: '  标准  ' });
    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledWith('BORROW', { keyword: '标准', pageSize: 100 }));

    apiMocks.getPersonalFolderFiles.mockClear();
    wrapper.findComponent({ name: 'BasicLeftTree' }).vm.$emit('select', 'DOWNLOAD');
    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledWith('DOWNLOAD', { keyword: undefined, pageSize: 100 }));
    expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledOnce();
    expect(formState.setFieldsValue).toHaveBeenCalledWith({ keyword: '' });

    await vi.waitFor(() => {
      const labels = (wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[]).map((action) => action.label);
      expect(labels).toEqual(['预览', '下载']);
    });

    apiMocks.getPersonalFolderFiles.mockClear();
    wrapper.findComponent({ name: 'BasicForm' }).vm.$emit('reset');
    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledWith('DOWNLOAD', { keyword: undefined, pageSize: 100 }));
    expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledOnce();
  });

  it('selects rows and previews non-action cells from table events', async () => {
    const wrapper = mountPage();
    await vi.waitFor(() => expect(wrapper.find('.file-name-trigger').exists()).toBe(true));

    const table = wrapper.findComponent({ name: 'BasicVxeTable' });
    const record = file({ fileName: 'BORROW.pdf', id: 'BORROW-file' });
    table.vm.$emit('row-click', { row: record });
    await nextTick();
    expect(wrapper.find('.file-name-trigger').attributes('aria-selected')).toBe('true');

    table.vm.$emit('cell-dblclick', { column: { field: 'fileName' }, row: record });
    await vi.waitFor(() =>
      expect(previewMocks.open).toHaveBeenCalledWith(
        expect.objectContaining({ fileName: 'BORROW.pdf', resourceId: 'BORROW-file', resourceType: 'FILE_VERSION' }),
      ),
    );

    previewMocks.open.mockClear();
    table.vm.$emit('cell-dblclick', { column: { field: 'action' }, row: record });
    await nextTick();
    expect(previewMocks.open).not.toHaveBeenCalled();
  });

  it('keeps Enter preview available in details and tile views', async () => {
    const wrapper = mountPage();
    await vi.waitFor(() => expect(wrapper.find('.file-name-trigger').exists()).toBe(true));

    await wrapper.find('.file-name-trigger').trigger('keydown.enter');
    expect(previewMocks.open).toHaveBeenCalledWith(
      expect.objectContaining({ fileName: 'BORROW.pdf', resourceId: 'BORROW-file', resourceType: 'FILE_VERSION' }),
    );

    previewMocks.open.mockClear();
    wrapper.findComponent({ name: 'FileViewModeSwitch' }).vm.$emit('update:value', 'tiles');
    await nextTick();
    await wrapper.find('.file-tile').trigger('keydown.enter');
    expect(previewMocks.open).toHaveBeenCalledWith(
      expect.objectContaining({ fileName: 'BORROW.pdf', resourceId: 'BORROW-file', resourceType: 'FILE_VERSION' }),
    );
  });

  it('disables expired preview actions', async () => {
    apiMocks.getPersonalFolderFiles.mockResolvedValueOnce({ data: [file({ validTo: '2000-01-01T00:00:00Z' })] });
    const wrapper = mountPage();
    await vi.waitFor(() => expect(wrapper.findComponent({ name: 'TableAction' }).exists()).toBe(true));

    const [previewAction] = wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[];
    expect(previewAction.disabled).toBe(true);
    await previewAction.onClick();
    expect(previewMocks.open).not.toHaveBeenCalled();
  });

  it('downloads through a ticket only from the download folder action', async () => {
    const wrapper = mountPage();
    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledOnce());

    wrapper.findComponent({ name: 'BasicLeftTree' }).vm.$emit('select', 'DOWNLOAD');
    await vi.waitFor(() => {
      const actions = wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[];
      expect(actions.map((action) => action.label)).toEqual(['预览', '下载']);
    });

    const downloadAction = (wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[])[1];
    await downloadAction.onClick();
    expect(apiMocks.createDmsFileDownloadTicket).not.toHaveBeenCalled();
    wrapper.findComponent({ name: 'BasicModal' }).vm.$emit('ok');
    await vi.waitFor(() => expect(utilityMocks.downloadByData).toHaveBeenCalled());

    expect(apiMocks.createDmsFileDownloadTicket).toHaveBeenCalledWith('DOWNLOAD-file', { watermarkBusinessTypes: ['gerenWenjianjia'] });
    expect(apiMocks.evaluatePersonalFolderDownloads).toHaveBeenCalledWith(['DOWNLOAD-file']);
    expect(apiMocks.downloadDmsFile).toHaveBeenCalledWith('DOWNLOAD-file', 'ticket-1', 'pdf');
    expect(utilityMocks.downloadByData).toHaveBeenCalledWith(expect.any(Blob), 'DOWNLOAD.pdf', 'application/pdf');
  });
  it('downloads Word only after confirming the selected format', async () => {
    apiMocks.getPersonalFolderFiles.mockResolvedValue({ data: [file({ fileName: 'manual.docx', id: 'word-file' })] });
    apiMocks.createDmsFileDownloadTicket.mockResolvedValue({ data: { accessTicket: 'word-ticket', fileName: 'manual.docx', fileVersionId: 'word-file' } });
    const wrapper = mountPage();
    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledOnce());
    wrapper.findComponent({ name: 'BasicLeftTree' }).vm.$emit('select', 'DOWNLOAD');
    await vi.waitFor(() => expect(wrapper.findComponent({ name: 'TableAction' }).props('actions')).toHaveLength(2));
    const action = (wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[])[1];
    await action.onClick();
    expect(apiMocks.createDmsFileDownloadTicket).not.toHaveBeenCalled();
    wrapper.findComponent({ name: 'BasicModal' }).vm.$emit('ok');
    await vi.waitFor(() => expect(apiMocks.downloadDmsFile).toHaveBeenCalledWith('word-file', 'word-ticket', undefined));
  });
  it('explains expired download authorization without requesting a ticket', async () => {
    apiMocks.getPersonalFolderFiles.mockResolvedValue({ data: [file({ validTo: '2000-01-01T00:00:00Z' })] });
    const wrapper = mountPage();
    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledOnce());
    wrapper.findComponent({ name: 'BasicLeftTree' }).vm.$emit('select', 'DOWNLOAD');
    await vi.waitFor(() => expect(wrapper.findComponent({ name: 'TableAction' }).props('actions')).toHaveLength(2));
    const action = (wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[])[1];
    expect(action.disabled).toBe(true);
    expect(apiMocks.createDmsFileDownloadTicket).not.toHaveBeenCalled();
  });

  it('disables downloads for expired file lifecycle and exhausted workflow authorization', async () => {
    apiMocks.getPersonalFolderFiles.mockImplementation(async (folderType: string) => ({
      data: folderType === 'DOWNLOAD' ? [file({ id: 'expired', lifecycleStatus: 'EXPIRED' }), file({ id: 'used' })] : [file()],
    }));
    apiMocks.evaluatePersonalFolderDownloads.mockResolvedValue({
      data: [
        { allowed: true, resourceId: 'expired' },
        { allowed: false, resourceId: 'used' },
      ],
    });
    const wrapper = mountPage();
    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledOnce());
    wrapper.findComponent({ name: 'BasicLeftTree' }).vm.$emit('select', 'DOWNLOAD');
    await vi.waitFor(() => expect(wrapper.findAllComponents({ name: 'TableAction' })).toHaveLength(2));
    expect(wrapper.findAllComponents({ name: 'TableAction' }).map((item) => (item.props('actions') as any[])[1].disabled)).toEqual([true, true]);
    expect(apiMocks.evaluatePersonalFolderDownloads).toHaveBeenCalledWith(['expired', 'used']);
  });

  it('disables download when authorization expires while the page stays open', async () => {
    const deadline = Date.now() + 1000;
    apiMocks.getPersonalFolderFiles.mockResolvedValue({ data: [file({ validTo: new Date(deadline).toISOString() })] });
    const wrapper = mountPage();
    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledOnce());
    wrapper.findComponent({ name: 'BasicLeftTree' }).vm.$emit('select', 'DOWNLOAD');
    await vi.waitFor(() => expect((wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[])[1].disabled).toBe(false));
    await vi.waitFor(() => expect((wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[])[1].disabled).toBe(true), { timeout: 2000 });
    wrapper.unmount();
  });

  it('disables download as soon as the ticket is issued', async () => {
    apiMocks.downloadDmsFile.mockReturnValue(new Promise(() => {}));
    const wrapper = mountPage();
    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledOnce());
    wrapper.findComponent({ name: 'BasicLeftTree' }).vm.$emit('select', 'DOWNLOAD');
    await vi.waitFor(() => expect((wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[])[1].disabled).toBe(false));
    (wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[])[1].onClick();
    wrapper.findComponent({ name: 'BasicModal' }).vm.$emit('ok');
    await vi.waitFor(() => expect(apiMocks.downloadDmsFile).toHaveBeenCalledOnce());
    expect((wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[])[1].disabled).toBe(true);
  });

  it('explains expiry while the format dialog is open', async () => {
    const deadline = Date.now() + 60_000;
    apiMocks.getPersonalFolderFiles.mockResolvedValue({ data: [file({ validTo: new Date(deadline).toISOString() })] });
    const wrapper = mountPage();
    await vi.waitFor(() => expect(apiMocks.getPersonalFolderFiles).toHaveBeenCalledOnce());
    wrapper.findComponent({ name: 'BasicLeftTree' }).vm.$emit('select', 'DOWNLOAD');
    await vi.waitFor(() => expect(wrapper.findComponent({ name: 'TableAction' }).props('actions')).toHaveLength(2));
    await (wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[])[1].onClick();
    const clock = vi.spyOn(Date, 'now').mockReturnValue(deadline);
    try {
      wrapper.findComponent({ name: 'BasicModal' }).vm.$emit('ok');
      await nextTick();
      expect(messageMocks.error).toHaveBeenCalledWith('下载授权已过期，请重新提交下载申请');
      expect(apiMocks.createDmsFileDownloadTicket).not.toHaveBeenCalled();
    } finally {
      clock.mockRestore();
    }
  });
});