import { request } from '@eciol/request';
import * as _ from 'lodash-es';

import { PartnerConfirmStatusEnum } from '@/views/job-list/manual-list/constants';
import { TaskDetail, TaskType, Type } from '#/jas';

import { getExternalTaskListByTaskIds } from './transdoc';
import type { OfflineService } from './typing';

enum Api {
  GetExternalTaskList = '/system-oms/purorder/page/forpartner',
  GetTaskDetail = '/system-oms/purorder/detail',
  GetMemoDetail = '/tbms-task/detail/pmTranslationTaskDetail',
  Approve = '/system-oms/purorder/confirm/bypartner',
}

class OfflineApi {
  /**
   * 对 task type 类型进行归类
   * @param list
   * @returns
   */
  private typeTransform(task: TaskDetail): TaskDetail {
    function getType(data: TaskDetail) {
      let type: Type;
      switch (_.toUpper(data.taskType)) {
        case _.toUpper(TaskType.TEP):
          type = Type.TEP;
          break;
        case _.toUpper(TaskType.T):
        case _.toUpper(TaskType.E):
        case _.toUpper(TaskType.QA):
        case _.toUpper(TaskType.P):
          type = Type.T;
          break;
        default:
          type = Type.DTP;
          break;
      }
      return type;
    }
    return {
      taskId: task.taskId,
      type: getType(task),
    };
  }
  /**
   * 获取外部资源任务列表
   */
  getTaskList = async (data: OfflineService.GetExternalTaskListParams) => {
    const result =
      (await request.post<OfflineService.GetExternalTaskListResult>(
        {
          url: Api.GetExternalTaskList,
          data,
        },
        {
          showLoading: true,
        },
      )) ?? {};
    if (result.data?.length) {
      const taskList = await getExternalTaskListByTaskIds({
        taskIds: result.data?.map((item) => item.taskId) ?? [],
      });
      result.data?.map((item) => {
        item.transDocLink = taskList?.find((_item) => _item.taskId === item.taskId)?.link;
        return item;
      });
    }

    return result;
  };

  getTaskDetail = async (data: { id: number }) => {
    const result =
      (await request.post<OfflineService.GetExternalTaskListResult>(
        {
          url: Api.GetTaskDetail,
          data,
        },
        {
          showLoading: true,
        },
      )) ?? {};
    return result;
  };

  getMemoDetail = async (data: { taskId: number }) => {
    const result =
      (await request.post<any>(
        {
          url: Api.GetMemoDetail,
          data,
        },
        {
          showLoading: true,
        },
      )) ?? {};
    return this.typeTransform(result);
  };

  async approve(data: { idList: (string | number)[]; confirmStatus: PartnerConfirmStatusEnum }) {
    try {
      await request.post<boolean>(
        {
          url: Api.Approve,
          data,
        },
        {
          showLoading: true,
          operationType: 'OPERATION',
          successMessageMode: 'message',
        },
      );
      return true;
    } catch {
      return false;
    }
  }
}
const offlineApi = new OfflineApi();

export { offlineApi };
export type { OfflineService };