import type {
  MonographDTO,
  MonographSubmitVO,
  MonographVO,
} from './monograph.schema';

import type { PageQueryMethodArgs } from '#/request/schema';
import type { PageDTO } from '#/request/schema/record';

import { getEnvelopeData, httpClient } from '#/request';
import {
  pageQueryArgsTransform,
  paginateTransform,
  transform,
} from '#/request/schema';

import {
  mockDeleteMonographMethod,
  mockEditMonographMethod,
  mockGetMonographMethod,
  mockListMonographMethod,
  USE_MONOGRAPH_MOCK,
} from './monograph.mock';
import {
  decodeMonograph,
  decodeMonographType,
  encodeMonograph,
  encodeMonographQuery,
  filterMonographPageByCategory,
} from './monograph.schema';

export { USE_MONOGRAPH_MOCK } from './monograph.mock';
export type {
  MonographCategory,
  MonographQueryVO,
  MonographSubmitVO,
  MonographVO,
} from './monograph.schema';
export {
  getMonographCategoryLabel,
  MONOGRAPH_CATEGORY_OPTIONS,
  MonographVOSchema,
} from './monograph.schema';

/** 论著分页列表 */
export function listMonographMethod(...args: PageQueryMethodArgs) {
  if (USE_MONOGRAPH_MOCK) {
    return mockListMonographMethod(...args) as any;
  }

  const { params, data } = pageQueryArgsTransform(args, encodeMonographQuery);
  const filterCategory = data.type ? decodeMonographType(data.type) : undefined;

  return httpClient.Post(
    `/wis-pc/outcome/treatiseManage/page`,
    { ...params, ...data },
    {
      params,
      hitSource: /^outcome-monograph:(edit|delete)/,
      transform: (page: PageDTO<MonographDTO>) =>
        filterMonographPageByCategory(
          paginateTransform(decodeMonograph)(page),
          filterCategory,
        ),
    },
  );
}

/** 新增论著 */
export function createMonographMethod(vo: MonographSubmitVO) {
  if (USE_MONOGRAPH_MOCK) {
    return mockEditMonographMethod(vo) as any;
  }

  return httpClient.Post(
    `/wis-pc/outcome/treatiseManage/add`,
    encodeMonograph(vo),
    {
      name: 'outcome-monograph:edit',
      transform: getEnvelopeData<null | string>,
    },
  );
}

/** 修改论著 */
export function updateMonographMethod(vo: MonographSubmitVO) {
  if (USE_MONOGRAPH_MOCK) {
    return mockEditMonographMethod(vo) as any;
  }

  return httpClient.Post(
    `/wis-pc/outcome/treatiseManage/update`,
    encodeMonograph(vo),
    {
      name: 'outcome-monograph:edit',
      transform: getEnvelopeData<null | string>,
    },
  );
}

/** 新增 / 修改论著 */
export function editMonographMethod(vo: MonographSubmitVO) {
  return vo.id ? updateMonographMethod(vo) : createMonographMethod(vo);
}

/** 论著详情 */
export function getMonographMethod(vo: Partial<MonographVO>) {
  if (USE_MONOGRAPH_MOCK) {
    return mockGetMonographMethod(vo) as any;
  }

  return httpClient.Post(
    `/wis-pc/outcome/treatiseManage/detail/${vo.id}`,
    {},
    {
      hitSource: /^outcome-monograph:edit/,
      transform: transform(decodeMonograph),
    },
  );
}

/** 删除论著 */
export function deleteMonographMethod(vo: Pick<MonographVO, 'id'>) {
  if (USE_MONOGRAPH_MOCK) {
    return mockDeleteMonographMethod(vo) as any;
  }

  return httpClient.Post(
    `/wis-pc/outcome/treatiseManage/delete/${vo.id}`,
    {},
    {
      name: 'outcome-monograph:delete',
      meta: { ignoreError: true },
    },
  );
}