import message from 'antd/lib/message';
import { shellHandler, ShellResult } from './shell';
import { tools } from "./tools";

export type cameraRect = {
  x: number;
  y: number;
  width: number;
  height: number;
  widthScreen: number;
  heightScreen: number;
}


export type OfflineImg = {
  tableName: string;//新增 表名
  primaryKey: string;//新增 主键名称
  primaryValue: string;//新增 主键值
  fieldName: string;//新增  图片的
}
export type DeviceInfo = {
  model: string,           // 设备型号
  name: string,            // 设备系统
  version: string,         // 系统版本
  versionName: string;     //版本号
  vendor: string,          // 设备供应商
  density: number,         // 密度
  resolutionWidth: number, // 真实宽度
  resolutionHeight: number, // 真实高度
  uuid: string,            // 设备唯一主键（设备号）
  scale: number,           // 尺寸
  isSupportFinger: boolean;  //是否支持指纹 目前仅安卓设备给出改字段
  isTerminal: boolean;  //是否pda  true ：是
}

export type FingerSuccessInfo = {
  finger: string
  fingerType: string
  isFinger: boolean
  matched: boolean
  userid?: string
  msg?: string
}

export type FingerFailInfo = {
  code: number
  text: string
}

type GPS = {
  longtitude: number;
  latitude: number;
  adress: string;
  contry: string;
  province: string;
  type: number
}
export interface CompanyInfo {
  envUrl: string;
  msg?: string;
}
export type ImgInfo = {
  dataurl: string,//base64
  filename: string,//文件名称
}
export interface FLColumn {
  dataType: string;//数据类型
  textAlign: number;//对齐方式：左中右
  fieldName: string;//列名称
  fieldCaption: string;//列中文名称
  colspan: number;//占列
  rowspan: number;//占行
  children?: FLColumn[];
}
export interface FileUiObj {
  fileName: string;//文件名
  fileType: 'xlsx' | 'csv';//文件类型
  columns: FLColumn[];//导出的列ui
  pageHeader: string;//页眉
  pageFooter: string;//页脚
}
export interface FileExportOver {
  type: 0 | 1;//0下载，1取消
}

interface IChooseImage {
  count?: number,//最多可以选择的图片张数 壳默认1张
  sizeType?: Array<'original' | 'compressed'>,//所选的图片的尺寸（原图、缩略图）
  sourceType: 'album' | 'camera',//选择图片的来源（相册、相机）
  type?: string; //选择图片类型限制
}

export interface IChooseFile {
  count?: number, // 最多可以选择的文件个数
  type?: 'all' | 'video' | 'image' | 'file' | string
  // all  从所有文件选择
  // video 只能选择视频文件
  // image 只能选择图片文件
  // file 可以选择除了图片和视频之外的其它的文件
  // 兼容内容页文件上传,可以通过传,号分割的字符串来进行类型限制
}

export interface ITranslateText {
  path: string
}

interface IPlayVoice {
  path: string, // 音频地址
  playType: 1 | 2 // 1 扬声器 2听筒
}
export interface ExternalUrlParms {
  externalUrl: string,
  fileName: string,
  handleType: string    //  (save / open)
}
export interface H5PrintParams {
  printer: string; //打印机名称
  count: number; //打印份数
  width: number; //纸张宽度
  domWidth: number; //dom宽度
  height: number; //纸张高度
  domHeight: number; //dom高度
  content: string; //base64
  status: number; //打印状态 0:开始 1:结束 2:进行中 3:仅有一页
  index: number; //索引值(页码)
  itemFlag: string; //唯一值
  landscape: boolean; //是否是横向打印 默认false纵向 true横向
  itemCaption: string; //打印的item标题 用于回调提示
  scale: number; //缩放倍数
}
export class Shell {
  // 不允许实例
  private constructor() { };

  /**
   * 判断是否在壳环境
   */
  static hasShell(): boolean {
    if ((tools.os.ios || tools.isMac) && window.webkit && !tools.isWeiXin()) {
      return true;
    } else if (window.AppShell) {
      return true;
    }
    return false;
  }
  /**
   * window.onerror发送报错信息
   */
  static sendError(content: string) {
    return shellHandler({ name: 'sendError', data: { content } });
  }
  /**
   *
   * @param downloadAdd
   */
  static restartApplication() {
    return shellHandler({ name: 'restartApplication' });
  }
  /**
   *
   * @param code
   */
  static setDownLoadUrl(downloadAdd: string) {
    return shellHandler<{ msg: string }, { downloadAdd: string }>({ name: 'setDownLoadUrl', data: { downloadAdd } });
  }
  /**
   * 修改客户编码
   * @param {string} code 客户编码
   * @return {Promise<CompanyInfo>} 返回设备信息
   */
  static toCompany(code: string) {
    return shellHandler<CompanyInfo, { code: string }>({ name: 'toCompany', data: { code } });
  }

  // 获取客户代码对应服务器地址
  static getCompanyCode() {
    return shellHandler<{ companyCode: string }>({ name: "companyCode" })
  }

  /**
   * 获取设备信息
   * @return {Promise<DeviceInfo>} 返回设备信息
   */
  static getDevice() {
    return shellHandler<DeviceInfo>({ name: 'getDevice' });
  }

  // 微信登录
  static wechatinLogin() {
    return shellHandler<{ content: string, msg: string }>({ name: "wechatinLogin" });
  }
  /**
   * ping 网络检测
   * @param data 多组ping数据
   * @param success 成功回调
   * @param info info为false回调
   * @param fail 失败回调
   */
  static startPing(
    data: obj<any>,
    success: ShellDoneHandler<{ content: obj[], macAddress: any }>,
    info?: ShellDoneHandler<{ content: string }>,
    fail?: ShellFailHandler
  ) {
    return shellHandler({
      name: "startPing",
      data,
      success,
      info,
      fail
    })
  }


  /**
  * 操作PC多开的数据
  * @param companyCode    公司编号
  * @param environment    环境的MD5值
  * @param key    环境下需要保存的key值，如果已经存在，则覆盖
  * @param value  需要保存的值
  * @param type //操作类型， 0表示查询，1表示新增，2表示删除，其它返回失败信息
  */
  static moreOpenOperat({ companyCode, environment, key, value, type }: { companyCode?: string, environment?: any, key?: string, value?: string, type: 0 | 1 | 2 }) {
    return shellHandler({ name: 'execCacheDb', data: { companyCode, environment, key, value, type } })
  }

  /**
   * 打开扫码功能
   * @param {number} type 默认0，表示全部识别，1表示只识别英文和数字，2表示只识别数字，3表示只识别英文
   * @param btn 可配置input(手动输入),voice(语音识别),image(图像识别)。
   */
  //  btn:{ input?: boolean, voice?: boolean, image?: boolean }
  static getScanCode(type: 0 | 1 | 2 | 3 = 0, btn: any = {}): Promise<ShellResult<{
    content: string;
    msg: string;
    scanMode?: string;
  }>> {
    return new Promise((resolve, reject) => {
      shellHandler<{ content: string, msg: string }>({
        name: "scanCode",
        data: {
          scanType: type,
          showBtn: Object.keys(btn).reduce((str, key) => {
            if (btn[key]) {
              return str ? str + ',' + key : key;
            } else {
              return str;
            }
          }, '')
        }
      }).then(res => {
        if (res.success) {
          resolve(res)
        }
        if (res.success === false) {
          if (res.code == '-200') {
            message.error({
              content: res.msg || '设备不支持相机'
            })
          } else {
            resolve(res)
          }
        }
      })
    })
  }

  /**
   * 获取gps信息（Android,ios）
   */
  static getGPS() {
    return shellHandler<{ gps: obj<GPS>, msg: string }>({
      name: "getGPS"
    });
  }

  /**
   * 下载附件
   * @param {string} url 附件地址
   * 1保存  0:打开
   * @return {Promise<ShellResult<{msg: string}>>}
   */
  static download(url: string, name?: string, type?: number) {
    return shellHandler<{ msg: string }>({
      name: "dealFile",
      data: {
        type: type ?? (tools.isMb ? 0 : 1),
        downPath: url,
        name: name
      }
    });
  }

  /**
   * 打开网络文件
   * @param {string} url 文件路径
   */
  static openNetFile(url: string, fileName?: string) {
    return shellHandler<{ msg: string }>({
      name: "dealFile",
      data: {
        type: 0,
        downPath: url,
        name: fileName
      }
    });
  }



  /**
   * 打开文件
   */
  static openFile(type: number, path: string, params: string) {
    return shellHandler<{ msg: string }>({
      name: "openFile",
      data: {
        type,
        path,
        params
      }
    })
  }
  /**
   * 保存图片
   */
  static saveImg(img: string) {
    return shellHandler<{ msg: string }>({
      name: "saveImg",
      data: {
        img
      }
    })
  }

  /**
   *
   * @param "shareType": String， //分享类型，wx,qq
   * @param "content": String， //文字描述。
   * @param "FileData": String,     //图片也是文件的一种，存放data数据
   * @param "url": String      //链接
   */
  static shareInfo(type: string, content: string, img: string, url: string) {
    return shellHandler<{ msg: string }>({
      name: 'shareInfo',
      data: {
        shareType: type,
        content,
        fileData: img,
        url
      }
    })
  }

  /**
   * 软件检测
   */
  static checkSoftInfo(data: any) {
    return shellHandler<{ msg: string }>({
      name: "checkSoftInfo",
      data
    })
  }

  /**
   * 打印标签
   * @param {string} blob 图片数据，base64格式
   * @param {number} pieces 打印份数
   * @param {string} driveName 打印机编码
   * @param {number} width 纸张宽度
   * @param {number} height 纸张高度
   */
  // static labelPrint(blob: string, pieces: number, driveName: string, width: number, height: number) {
  //     return shellHandler<{ msg: string }>({
  //         name: "labelPrint",
  //         data: {
  //             quantity: pieces,
  //             driveName: driveName,
  //             image: blob,
  //             width,
  //             height
  //         }
  //     });
  // }
  /**
  * 打印标签标签UI设置
  * @param  data 标签UI设置
  */
  static setLabelUI(data: any, baseUrl: string) {
    return shellHandler<{ msg: string }>({
      name: "setLabelUI",
      data: Object.assign({}, data || {}, { baseUrl }),
    });
  }
  /**
  * 打印标签设置用户的配置
  * @param  data 用户的配置
  */
  static setUserConfig(data: any) {
    return shellHandler<{ msg: string }>({
      name: "setUserConfig",
      data,
    });
  }
  /**
  * 打印标签设置标签的数据
  * @param  dataList 数据
  * @param  meta 列名
  */
  static setLabelData(data: obj) {
    return shellHandler<{ msg: string }>({
      name: "setLabelData",
      data,
    });
  }
  /**
  * 打印标签预览
  * @param {number} pageIndex 预览的页数page
  */
  static labelPreview(pageIndex: number) {
    return shellHandler<{ msg: string, hasNextPage: boolean, filePath: string[] }>({
      name: "labelPreview",
      data: {
        // pageIndex: pageIndex,
        pageIndex: pageIndex,
      }
    });
  }
  /**
  * 打印标签
  * @param {number} printCount 打印份数
  */
  static labelPrint() {
    return shellHandler<{ msg: string }>({
      name: "labelPrint",
    });
  }
  /**
   * 清除上述的标签ui、用户设置、标签数据
   */
  static clearLabelData() {
    return shellHandler<{ msg: string }>({
      name: "clearLabelData",
    });
  }
  /**
   * 批量打印文件
   * @param {string} printer 打印机名称
   * @param {Array<{name: string, filePath: string, count: number}>} printData 打印内容
   * name文件名称，filePath文件路径，count打印份数
   */
  static filePrint(printer: string, printData: Array<{ name: string, filePath: string, count: number }>) {
    return shellHandler<{ msg: string }>({
      name: "filePrint",
      data: {
        printer,
        printData: printData
      }
    });
  }
  /**
   * 获取打印机列表信息
   */
  static getPrinters() {
    return shellHandler<{
      driveList: Array<{
        driveName: string, // 打印机名称
        driveCode: number // 打印机编号
      }>
    }>({
      name: "getPrinters"
    });
  }

  /**
   * 推送消息注册
   * @param flag 使用信鸽推送传入推送标识flag给壳注册，并把flag发送给后端(旧版使用的是(登录环境+用户名)MD5)
   * 接收apns时flag不用传，调用信鸽注册时要传（.....）
   * @return 返回值apns 是推送的pushId，发送给后端
   */

  static registMessage(flag: string) {
    return shellHandler<{ apns: string }>({
      name: "registMessage",
      data: {
        flag
      }

    });
  }

  /**
   * 图片压缩
   */
  static getAttachment(
    data: {
      maxHeight?: number,
      maxWidth?: number,
      maxSize?: number,
      minSize?: number,
      maxValue?: number,
      minValue?: number,
      multi?: boolean,
      type: number,
      rect?: cameraRect | null,
      count?: number
      offline?: {
        tableName: string;//新增 表名
        primaryKey: string;//新增 主键名称
        primaryValue: string;//新增 主键值
        fieldName: string;//新增  图片的
      }
    },
    info: ShellDoneHandler<ImgInfo>,
    success: ShellDoneHandler<ImgInfo>,
    fail?: ShellFailHandler
  ) {
    return shellHandler({ name: 'getAttachment', data, info, success, fail });
  }
  /**
   * 打开调试工具（pc,Android,ios）
   */
  static openDebug() {
    return shellHandler<{}>({
      name: "openDebug",
    });
  }

  /**
   * 指纹考勤长链接，进入页面时调用一次
   * 只走success
   */
  static openFinger(
    type: 0 | 1 = 1,
    success: any,
    info: any,
  ) {
    return shellHandler({ name: 'openFinger', data: { type }, success, info });
  }

  /**
   * 将指纹插入壳数据库
   */
  static addFinger(
    userid: string,
    matchFinger: string,
    fingerType: number
  ) {
    return shellHandler({ name: 'addFinger', data: { userid, matchFinger, fingerType } });
  }

  //关闭指纹长链接
  static closeFinger() {
    return shellHandler({ name: 'closeFinger' })
  }

  /**
   * 获取指纹 info调用形式
   * @param {number} type 指纹类型；0: 匹配校验指纹, 1: 注册指纹; 默认1;
   * @param success 成功回调
   * @param info 实时回调
   * @param fail 失败回调
   */
  static fingerGet(
    type: 0 | 1 = 1,
    success: ShellDoneHandler<{ fingerType: number, finger: string }>,
    info?: ShellDoneHandler<{ text: string }>,
    fail?: ShellFailHandler
  ) {
    return shellHandler({ name: 'getFinger', data: { type }, success, info, fail });
  }

  // 取消指纹
  static cancelFinger(fingerType: number) {
    return shellHandler<{ msg: string }>({ name: 'cancelFinger', data: { fingerType } });
  }

  /**
   * 指纹验证
   * @param {string} enterFinger 用户输入的指纹
   * @param {string} matchFinger 本地需要匹配的指纹
   * @param {string} fingerType 是那一种指纹器，值为0或1或2
   */
  static verifyFinger(enterFinger: string, matchFinger: string, fingerType: number) {
    return shellHandler<{ matched: boolean }>({
      name: "verifyFinger",
      data: {
        enterFinger,
        matchFinger,
        fingerType
      }
    });
  }

  /**
   * android清除历史
   */
  //清除历史
  static clearHistory() {
    return shellHandler({ name: 'clearHistory' })
  }

  /**
   * 卡西欧盘点上传
   */

  static casioUpload(
    data: {
      port: string,
      speed: string,
      url: string,
      token: string
    },
    success: ShellDoneHandler,
    fail: ShellFailHandler
  ) {
    return shellHandler({
      name: "casioUpload",
      data,
      success,
      fail
    });
  }

  /**
   * 卡西欧盘点下载
   */
  static casioDownLoad(
    data: {
      port: string,
      speed: string,
      url: string,
      token: string
    },
    success: ShellDoneHandler,
    fail: ShellFailHandler
  ) {
    return shellHandler({
      name: "casioDownLoad",
      data,
      success,
      fail
    });
  }
  /**
   * 截屏
   */
  static screenShot() {
    return shellHandler({ name: 'screenShot' })
  }

  /**
   * 开始录音
   * @param type 类型，如果是0，只在结束的时候返回结果，如果是1，返回过程
   */
  static startVoice(
    type = 0,
    success: ShellDoneHandler,
    fail: ShellFailHandler,
    info: ShellDoneHandler
  ) {
    return shellHandler({ name: 'startVoice', data: { type }, success, fail, info })
  }

  /**
   * 停止录音
   */
  static stopVoice() {
    return shellHandler({ name: 'stopVoice' });
  }

  /**
   * 朗读文字
   * @param content 要朗读的文字
   */
  static readVoice(content: any) {
    return shellHandler({ name: 'readVoice', data: { content } })
  }

  /**
   * 获取系统剪贴板的内容
   */
  static getClipboardData() {
    // let production = process.env.NODE_ENV === "production";
    // if (!production) {
    //     var a = {
    //         "scanType":1,
    //         "btnId": "h5-12",
    //         "dataList": [{
    //             "KEYVALUE":"CMS3",
    //             "IMAGE":"",
    //             "KEYFIELD":"测试1",
    //             "TITLE":"蔡明邀请你加入速狮公司"
    //         }],
    //         "h5Url": "http://www.baidu.com",
    //         "url": "/ui/node/n2-test-cht-1?p_n=%5B%7B%22n%22%3A%22node_test_bg%22%2C%22k%22%3A%22null%22%7D%5D"
    //     }
    //     var str = tools.encode(encodeURI(JSON.stringify(a)));
    //     var url = `${a.h5Url}?qrcodeshare=${str}`;
    //     return Promise.resolve({
    //         success: true,
    //         data: { content: url }
    //     })
    // }
    return shellHandler<{ content: string }>({ name: 'getFromPasteboard', data: {} })
  }
  /**
   * 建表
   * @param tableName 表名
   * @param key 主键名称
   */
  static execCreateTable(tableName: string, key: string) {
    return shellHandler({ name: 'sqlCreateTable', data: { tableName, key } })
  }
  /**
   * 新增数据
   * @param tableName 表名
   * @param key 主键名称
   * @param insertData 新增的数据
   */
  static execInsert(tableName: string, insertData: obj[], key: string) {
    return shellHandler({ name: 'sqlInsert', data: { tableName, insertData, key } })
  }
  /**
   * 查找表所有数据  或 单条数据
   * @param tableName 表名
   * @param key 主键名称 可不传
   * @param keyValue 主键值  可不传
   * 如果不传则代码查找表中所有数据
   */
  static execFind(tableName: string, keyValue?: string, key?: string) {
    return shellHandler<{ content: string }>({ name: 'sqlFind', data: { tableName, keyValue, key } })
  }
  /**
   * 删除数据 或 表
   * @param tableName 表名
   * @param key 主键名称 可不传
   * @param keyValue 主键值  可不传
   * 如果不传则代码删除所有数据
   */
  static execDelete(tableName: string, keyValue?: string, key?: string) {
    return shellHandler({ name: 'sqlDelete', data: { tableName, keyValue, key } })
  }
  /**
  * 更新数据
  * @param tableName 表名
  * @param key 主键名称
  * @param updateData 要更新的数组
  */
  static execUpdate(tableName: string, updateData: obj[], key: string) {
    return shellHandler({ name: 'sqlUpdate', data: { tableName, updateData, key } })
  }
  /**
   * 下载离线资源包
   */
  static downloadImgZip(url: string, method: string, requestParam: string) {
    return shellHandler({ name: 'downloadImg', data: { url, method, requestParam } })
  }
  /**
   * 离线上传图片
   */
  static offlineUloadImg(tableName: string, url: string, method: string) {
    return shellHandler({ name: 'uploadImg', data: { tableName, url, method } })
  }
  /**
  * 离线删除图片
  */
  static deleteFile(tableName: string, primaryKey?: string, primaryValue?: string, fieldName?: string, path?: string) {
    let opts: any = { tableName, primaryKey, primaryValue, fieldName, path };
    let newOpts: any = {};
    for (let i of Object.keys(opts)) {
      if (opts[i]) {
        newOpts[i] = opts[i]
      }
    }
    return shellHandler({ name: 'deleteFile', data: { tableName, primaryKey, primaryValue, fieldName, path } })
  }
  /**
   * 导入读取Excel
   */
  static readExcel(url: string) {
    return shellHandler<{ totalNumber: number }>({ name: 'readExcel', data: { url } })
  }
  /**
  * 获取已导入的Excel的数据
  */
  static getExcelData(startIndex: number, endIndex: number) {
    return shellHandler<{ data: obj<any>[], totalNumber: number }>({ name: 'getExcelData', data: { startIndex, endIndex } })
  }
  /**
  * 删除已导入的Excel的数据
  */
  static clearExcel() {
    return shellHandler({ name: 'clearExcel' })
  }
  /**
   * 离线上传图片
   */
  static setBadge(count: number) {
    return shellHandler({ name: 'setBadge', data: { count } })
  }

  /**
   * 远程协助
   */
  static remoteHelpStart(data: { canControl?: boolean, x?: number, y?: number, width?: number, height?: number }) {
    return shellHandler({ name: 'remoteHelpStart', data })
  }

  /**
   * 隐藏录制
   */
  static hideRecord() {
    return shellHandler({ name: 'hideRecord' })
  }

  /**
   * 结束远程协助
   */
  static remoteHelpStop(
    success: ShellDoneHandler,
    fail: ShellFailHandler
  ) {
    return shellHandler({ name: 'remoteHelpStop', success, fail })
  }

  /**
   * 远程控制
   */
  static remoteControl() {
    return shellHandler({ name: 'remoteControl' })
  }
  /**
   * 通知终端连接 socket
   */
  static connectSocket(data: obj) {
    return shellHandler({ name: 'connectSocket', data })
  }
  /**
   * 通知终端断开 socket
   */
  static closeSocket() {
    return shellHandler({ name: 'closeSocket' })
  }
  /**
   * 导出文件，发送ui给终端
   */
  static jsExcelUi(data: FileUiObj) {
    return shellHandler({ name: 'jsExcelUi', data })
  }
  /**
   * 导出文件，传递数据给终端
   */
  static jsExcelData(data: obj[]) {
    return shellHandler({ name: 'jsExcelData', data })
  }
  /**
   * 导出文件，结束
   */
  static jsExcelOver(data: FileExportOver) {
    return shellHandler({ name: 'jsExcelOver', data })
  }
  /**
  * 沟通反馈选择图片
  */
  static chooseImage<T>(data: IChooseImage) {
    return shellHandler<T>({ name: 'chooseImage', data })
  }
  /**
   * 上传
   * path 要上传的临时文件地址
   * url  上传的服务器地址
   */
  static uploadFile<T>(
    data: {
      path: string,
      url: string,
      chunkUpload?: boolean,
      formData?: obj<any>,
      header?: obj<any>
    },
    info: ShellDoneHandler<{ percent: number }>,
    success: ShellDoneHandler<T>,
    fail?: ShellFailHandler
  ) {
    return shellHandler({ name: 'uploadFile', data, info, success, fail })
  }

  /**
   * @description 开始录音
  */
  static startRecord() {
    return shellHandler({ name: 'startRecord' })
  }

  /**
   * @description 取消录音
  */
  static cancelRecord() {
    return shellHandler({ name: 'cancelRecord' })
  }

  /**
   * @description 结束录音
   */
  static stopRecord() {
    return shellHandler<{ path: string, time: number }>({ name: 'stopRecord' })
  }

  /**
   * @description 选择文件
   */
  static chooseFile<T>(data: IChooseFile) {
    return shellHandler<T>({ name: 'chooseFile', data })
  }

  /**
   * @description 语音转文字
   * @path 音频地址
   */
  static translateText(data: ITranslateText) {
    return shellHandler<{ text: string }>({ name: 'translateText', data })
  }

  /**
   * @description 语音播放
   * @path 音频地址
   * @playType 1 扬声器 2听筒
   */
  static playVoice<T>(data: IPlayVoice) {
    return shellHandler<T>({ name: 'playVoice', data })
  }
  /**
   * @description 停止播放语音
   */
  static stopPlayVoice() {
    return shellHandler({ name: 'stopPlayVoice' })
  }
  /* 打开外部Url
  * @param data
  * @returns
  */
  static handleExternalUrl(data: ExternalUrlParms) {
    return shellHandler<{ msg: string }>({ name: 'handleExternalUrl', data })
  }
  /*
   * h5打印
   */
  static h5Print(data: H5PrintParams) {
    return shellHandler({ name: 'h5Print', data })
  }
  // 独占式 PDA
  static pdaEnableScan(isEnabled: boolean) {
    return shellHandler({ name: 'pdaEnableScan', data: { isEnabled } })
  }

  /**
   * 预览文件
   */
  static previewFile(
    data: { urls: string[], current?: number }
  ) {
    return shellHandler({ name: 'previewFile', data })
  }

  /**
   * 打开拍照
   */
  static openCamera(count: number) {
    return shellHandler<{ tempFiles: any[] }>({ name: 'openCamera', data: { count } })
  }

  /**
   * 文件压缩
   */
  static compressImage(
    data: {
      url: string,
      maxHeight?: number,
      maxWidth?: number,
      maxSize?: number,
      minSize?: number,
      maxValue?: number,
      minValue?: number
    }
  ) {
    return shellHandler<{ tempFile: any }>({ name: 'compressImage', data })
  }

  /**
   * 下载文件流
   */
  static downloadFileStream(
    data: {
      url: string,
      params?: obj<any>,
      header?: obj<any>
    }
  ) {
    return shellHandler({ name: 'downloadFileStream', data })
  }

  /**
 * 开始rfid红外扫码
 */
  static UHFStartInfrared(timeout: any, success: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFStartInfrared",
      data: {
        timeout
      },
      success,
      fail: success
    })
  }
  /**
* 停止rfid红外扫码
*/
  static UHFStopInfrared() {
    return shellHandler<{ msg: string }>({
      name: "UHFStopInfrared",
    })
  }
  /**
   * 开始扫码rfid长连接 不关闭的情况下重复调用
   */
  static startRFIDScan(data: any, info: any, success: any, fail: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFStartScan",
      data: {
        isSound: true,
        ...data
      },
      fail,
      success,
      info
    })
  }
  /**
 * 开始找货rfid长连接 不关闭的情况下重复调用
 */
  static UHFStartSearch(info: any, success: any, searchType: any, searchData: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFStartSearch",
      data: {
        searchType,
        searchData
      },
      success,
      info
    })
  }
  /**
* 开始找货rfid长连接 不关闭的情况下重复调用
*/
  static UHFStartSearchForSKU(info: any, success: any, param: { sku: string }, fail: any) {

    return shellHandler<{ msg: string }>({
      name: "UHFStartSearchForSKU",
      data: { power: 30, ...param },
      success,
      fail,
      info
    })
  }
  /**
* 开始找货rfid长连接 不关闭的情况下重复调用
*/
  static UHFStartSearchForEPC(info: any, success: any, param: { epcList: string[] }, fail: any) {

    return shellHandler<{ msg: string }>({
      name: "UHFStartSearchForEPC",
      data: { power: 30, ...param },
      success,
      fail,
      info
    })
  }
  /**
* 关闭扫描
*/
  static UHFStopScan() {
    return shellHandler<{ msg: string }>({
      name: "UHFStopScan",
    })
  }
  /**
 * 关闭搜索
 */
  static UHFStopSearch() {
    return shellHandler<{ msg: string }>({
      name: "UHFStopSearch"
    })
  }
  /**
* 写入状态位
*/
  static UHFModify(filterEPCList: string[], writeByte: any, endFn: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFModify", data: {
        filterEPCList,
        writeByte
      },
      success: endFn,
      fail: endFn
    })
  }
  /**
* 写入状态位-pc使用-目前手持机没有
*/
  static UHFStopModify(endFn: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFStopModify",
      success: endFn,
      fail: endFn
    })
  }
  /**
* 读取白标
*/
  static UHFScanSingleBlankTag(data: any, endFn: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFScanSingleBlankTag", data: {
        power: 5,
        scanTime: 2,
        ...data
      },
      success: endFn,
      fail: endFn
    })
  }

  /**
  * 写入
  */
  static UHFWrite(epc: string, endFn: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFWrite", data: {
        epc
      },
      success: endFn
    })
  }
  /**
  * 写入目标epc
  */
  static UHFWriteTag(data: {
    tagEpc: string
    writeEpc: string
  }, endFn: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFWriteTag", data: {
        ...data,
        writeTime: 10

      },
      success: endFn,
      fail: endFn
    })
  }
  /**
 * 开始盘存
 */
  static UHFStartInventoryForEPC(param: { shelfText: string, epcList: string[] }, endFn: any, info: any, fail: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFStartInventoryForEPC", data: {
        isSound: true,
        ...param
      },
      fail,
      success: endFn,
      info
    })
  }
  static UHFStartInventoryForAll(param: { shelfText: string }, endFn: any, info: any, fail: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFStartInventoryForAll", data: {
        isSound: true,
        ...param
      },
      fail,
      success: endFn,
      info
    })
  }
  static UHFStartInventoryForBranch(param: { shelfText: string, branchNo: string }, endFn: any, info: any, fail: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFStartInventoryForBranch", data: {
        isSound: true,
        ...param
      },
      fail,
      success: endFn,
      info
    })
  }
  /**
  * 暂停盘存
  */
  static UHFPauseInventory(successFn?: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFPauseInventory",
      success: successFn
    })
  }
  /**
  * 获取当前盘存结果
  */
  static UHFGetInventoryResult(res: any) {
    return shellHandler<{ msg: string }>({
      name: "UHFGetInventoryResult",
      success: res,
      fail: res
    })
  }
  /**
* 继续盘存
*/
  static UHFResumeInventory(shelf: string) {
    return shellHandler<{ msg: string }>({
      name: "UHFResumeInventory",
      data: { shelf },
    })
  }
  /**
* 清空对应货架盘存数据
*/
  static UHFClearInventoryData(shelf: string) {
    return shellHandler<{ msg: string }>({
      name: "UHFClearInventoryData",
      data: { shelf },
    })
  }
  /**
  * 停止盘存
  */
  static UHFStopInventory() {
    return shellHandler<{ msg: string }>({
      name: "UHFStopInventory",
    })
  }
  /**
   * android预览pdf
   */
  static previewPdf(
    data: {
      url: string,
      name: string
    }
  ) {
    return shellHandler({ name: 'previewPdf', data })
  }
}