import { SchemaCollection } from ".."
import { expressLabels, IExpress } from "../renderers/Lion/ExpressPrint/ExpressPrint"
import { Api } from "../types"
import { Shell } from "./shell"
import MSG from '../renderers/Lion/utils/msgsub';
import { message } from "antd";
import { switchCase } from "@babel/types";
import { isMobile } from "./helper";
import { getModifyResult } from "./RfidUtil";

interface ScanAfterLabelPrint {
  labelData: any[]
  labelTemplate: any
  labelPrinter: string
}

interface FrontPort {
  afterApi: Api
  bodyList: { EPC: string }[]
  EPC: string
  portId: 'rfid-in-stock' | 'rfid-sold' | 'rfid-scrap' | 'rfid-been-dispatched'
}

interface ScanAfterPort {
  afterApi?: Api
  body: IExpress
}

interface ScanAfterShow {
  showType: 0 | 1 | 2 | 10 | 11 | 12
  showMsg: string
  afterApi?: Api
}

interface ScanAfterVars {
  afterApi: Api
  body: SchemaCollection
  data: object
}


export interface ScanAfterDo {
  cmd: 'STEP_PRINT_LABEL' | 'STEP_PORT' | 'STEP_SHOW' | 'STEP_VARS' | 'STEP_FRONT_PORT'
  body: ScanAfterLabelPrint | ScanAfterPort | ScanAfterShow | ScanAfterVars | FrontPort
}

// rfid keystep功能port enum
enum RFIDPortIdEnum {
  RFIDINSTOCK = 'rfid-in-stock', // 在库
  RFIDSOLD = 'rfid-sold', // 已售
  RFIDSCRAP = 'rfid-scrap', // 废弃
  RFIDBEENDISPATCHED = 'rfid-been-dispatched',  // 调出
  RFIDEPCOVERWRITE = 'rfid-epc-overwrite' // 覆写
}
// keyStep脚本函数 专门处理keyStep脚本，识别到有通用化的趋势，故此抽出
// 第一个是执行剩下的按钮用的
export const KeyStepCommonFunction = async (scanAfterDo: ScanAfterDo[], data: any, env: any, props: any, errorHandle?: (restScanDo: ScanAfterDo[], data: any, env: any, errorData: any) => any) => {
  for (const key in scanAfterDo) {
    if (Object.prototype.hasOwnProperty.call(scanAfterDo, key)) {
      const element = scanAfterDo[key];
      const cmd = element.cmd
      let outFlag = false // 中断标识
      let payload // 返回集中存放
      let errorData = undefined // 错误数据 用于判断
      switch (cmd) {
        case "STEP_FRONT_PORT": {
          const body = element.body as FrontPort
          const bodyList = body.bodyList // 获取需要设置的请求体
          const portId = body.portId // 获取需要设置的请求体
          {
            // portId对应的状态码
            const statusMap = isMobile() ? {
              [RFIDPortIdEnum.RFIDINSTOCK]: 0x00, // 在库
              [RFIDPortIdEnum.RFIDSOLD]: 0x10, // 已销售
              [RFIDPortIdEnum.RFIDBEENDISPATCHED]: 0x20, // 已调出
              [RFIDPortIdEnum.RFIDSCRAP]: 0x30, // 已废弃
            } : {
              [RFIDPortIdEnum.RFIDINSTOCK]: '0', // 在库
              [RFIDPortIdEnum.RFIDSOLD]: '1', // 已销售
              [RFIDPortIdEnum.RFIDBEENDISPATCHED]: '2', // 已调出
              [RFIDPortIdEnum.RFIDSCRAP]: '3', // 已废弃
            } // pc端的比较简单 直接写入就行
            const epcList = bodyList.filter(_ => _.EPC).map(_ => _.EPC)
            // const epcList = ['38739204B0100000001']
            // 固定取bodyList里面的东西 方便处理
            switch (portId as RFIDPortIdEnum) {
              case RFIDPortIdEnum.RFIDINSTOCK:
              case RFIDPortIdEnum.RFIDSOLD:
              case RFIDPortIdEnum.RFIDSCRAP:
              case RFIDPortIdEnum.RFIDBEENDISPATCHED:
                if (epcList.length) {
                  message.loading('写入中')
                  const res: any = await getModifyResult(epcList, statusMap[portId])
                  message.destroy()
                  console.log('结果', JSON.stringify(res))
                  const failList = res?.data?.failList

                  if (failList.length) {
                    outFlag = true
                    errorData = failList
                    // 调整下一次要处理的列表
                    body.bodyList = failList.map((_: string) => ({ EPC: _ }))
                    message.warn(`写入失败epc码,${failList.join(',')}`)
                  } else {
                    message.success(`写入成功`)
                    if (body.afterApi)
                      payload = await env.fetcher(body.afterApi, data)
                  }
                } else {
                  message.warn('需要设置的EPC码为空')
                }
                break;
              case RFIDPortIdEnum.RFIDEPCOVERWRITE:
                // 约定获取第一条的epc写入 到时候要加个提示
                Shell.UHFWrite(bodyList[0].EPC, (res: any) => {
                  if (res.code == -200) {
                    message.warn(res.detail || '写入失败 ')
                  } else {
                    message.success(`写入成功`)
                  }
                  console.log(JSON.stringify(res), '写入结果')
                })
                break;
              default:
                message.warn('未指定的portId')
                break;
            }
          }
          break;
        }
        case 'STEP_PORT':
          const portBody = element.body as ScanAfterPort
          await expressLabels(portBody?.body, env.fetcher, props.translate, props.showModal === 1)
          if (portBody.afterApi) {
            payload = await env.fetcher(portBody.afterApi, data)
          }
          break
        case 'STEP_SHOW':
          const body = element.body as ScanAfterShow
          const { showMsg, showType, afterApi } = body
          if (showType == 0 || showType == 10) {
            if (showType == 10) Shell.readVoice(showMsg)
            MSG._info(showMsg)
            if (afterApi) {
              payload = await env.fetcher(afterApi, data)
            }
          } else if (showType == 1 || showType == 11) {
            if (showType == 11) Shell.readVoice(showMsg)
            const confirm = await env.confirm(showMsg)
            if (confirm && afterApi) {
              payload = await env.fetcher(afterApi, data)
            }
          } else if (showType == 2 || showType == 12) {
            if (showType == 12) Shell.readVoice(showMsg)
            env.confirm(showMsg, undefined, undefined, false)
          }
          break
        case 'STEP_VARS':
          const varsBody = element.body as ScanAfterVars
          const formData = await env.prompt(varsBody.body, varsBody.data)
          if (formData !== false && varsBody.afterApi) {
            payload = await env.fetcher(varsBody.afterApi, { ...formData, ...data })
          }
          break
        default:
          break
      }


      if (outFlag) {
        errorHandle?.(scanAfterDo.slice(+key), data, env, errorData)
        break;
      }
      if (payload)
        if (payload?.ok && payload?.status == 20003) {
          await KeyStepCommonFunction(payload.data.scanAfterDo, data, env, props, errorHandle)
        } else {
          payload.msg && message.warn(payload.msg)
        }
    }
  }
}