<!--
  费率配置：

  @author terrfly
  @site https://www.jeequan.com
  @date 2022/04/06 10:14
-->

<!--

   费率配置面板，  支持9种模式： 

  ( mgrIsv ) 运营平台对服务商的配置：  查询【服务商所有支持的支付方式】
  支付产品 、 [配置]服务商底价、  [配置]代理商默认费率、  [配置]商户默认费率。 

  ( mgrAgent ) 运营平台对代理商的费率配置： 查询： 【代理的所属服务商 、 所属上级代理商的所有开通的支付产品】 
  支付产品、 [显示]服务商底价， [显示]上级代理商费率、  [配置]代理商的费率、  [配置]下级代理商的默认费率、  [配置]商户默认费率。 

  ( mgrMch ) 运营平台对商户：  查询【商户的所属服务商 、 所属上级代理商的所有开通的支付产品】
  支付产品、 [显示]服务商底价， [显示]上级代理商费率、  [配置]商户的费率。 

  ( agentSelf ) 代理商 对自己：   查询【当前代理商已经开通的产品】
  支付产品、 [显示]当前代理商的费率、  [配置]下级代理商的默认费率、  [配置]商户默认费率。

  ( agentSubagent ) 代理商对下级代理商：  查询【当前代理商已经开通的产品】
  支付产品、 [显示]当前代理商的费率、  [配置]下级代理商的费率

  ( agentMch ) 代理商对商户： 查询【当前代理商已经开通的产品】
  支付产品、 [显示]上级代理商费率、  [配置]商户的费率。 


  ( mgrApplyment ) 显示方式同： mgrMch。  只是不需要 切换支付接口和保存按钮    新增按钮： 查询默认费率。 

  ( agentApplyment ) 显示方式同： agentMch  只是不需要 切换支付接口和保存按钮.   新增按钮： 查询默认费率。 

  ( mchApplyment ) 不需要 切换支付接口和保存按钮.   显示的就是代理商或者服务商配置的默认费率。 
  -->

<template>
  <div class="drawer">
    <!-- 费率配置 面板   仅选择了支付接口才可见 -->
    <div v-if="vdata.currentIfCode" style="margin-bottom: 15px;">
      <!-- 新版费率配置模板  微信  -->
      <JeepayPaywayRatePanelInnerPaywayTypeCard wayType="WECHAT" :configMode="props.configMode" />

      <!-- 新版费率配置模板 支付宝 -->
      <JeepayPaywayRatePanelInnerPaywayTypeCard wayType="ALIPAY" :configMode="props.configMode" />

      <!-- 新版费率配置模板 云闪付 -->
      <JeepayPaywayRatePanelInnerPaywayTypeCard wayType="YSFPAY" :configMode="props.configMode" />

      <!-- 新版费率配置模板 银联 -->
      <JeepayPaywayRatePanelInnerPaywayTypeCard wayType="UNIONPAY" :configMode="props.configMode" />

      <!-- 新版费率配置模板 数字人民币 -->
      <JeepayPaywayRatePanelInnerPaywayTypeCard wayType="DCEPPAY" :configMode="props.configMode" />

      <!-- 新版费率配置模板 其他 -->
      <JeepayPaywayRatePanelInnerPaywayTypeCard wayType="OTHERS" :configMode="props.configMode" />


      <a-modal v-model:visible="vdata.showSetFeeModal" title="设置费率" @ok="handleOkFunc">
        <a-form>
          <a-form-item v-if="props.mode != 'mchApplyment'" label="统一设置费率值：">
            <a-input-number v-model:value="vdata.showSetFeeModalValue" /> %
          </a-form-item>
    
          <a-form-item label="统一设置是否开通：">
            <a-radio-group v-model:value="vdata.showSetIsOpenValue">
              <a-radio :value="true">开通</a-radio><a-radio :value="false">关闭</a-radio>
            </a-radio-group>
          </a-form-item>
        </a-form>
      </a-modal>
    </div>
    
    <!-- 只有运营平台配置的商户， 才可以配置 商户0费率  -->
    <a-collapse v-if="props.configMode == 'mgrMch'">
      <a-collapse-panel key="a1" header="【保存】高级配置项">
        <a-checkbox v-model:checked="vdata.noCheckRuleFlag">本商户为特殊商户， 不校验上下级的费率比较规则， 允许低于服务商的底价。 </a-checkbox>
      </a-collapse-panel>
    </a-collapse>
    
    <!-- 只有运营平台配置的 服务商， 才可以 忽略项目  -->
    <a-collapse v-if="props.configMode == 'mgrIsv'">
      <a-collapse-panel key="a2" header="【保存】高级配置项">
        <a-checkbox v-model:checked="vdata.noCheckRuleFlag">不校验服务商的费率配置信息 （仅特殊情况才可使用）。 </a-checkbox>
      </a-collapse-panel>
    </a-collapse>
    
    <div v-if="!props.onlyRate && showSaveBtn" class="drawer-btn-center">
      <a-button type="primary" @click="onSubmit"><check-outlined />保存</a-button>
    </div>
  </div>
</template>
    
  <script lang="ts" setup >
  import { $getRateConfigPayways, $getRateConfigSavedMapData, $saveRateConfig } from '@/api/manage'
  import { reactive, getCurrentInstance, onMounted, defineExpose, provide, computed } from 'vue'
  
  // 导入全局函数
  const { $infoBox, $hasAgentEnt } = getCurrentInstance()!.appContext.config.globalProperties
  
  // 定义父组件的传值
  const props : any = defineProps({
  
    infoId: { type: String, default: '' }, // 当前配置的所属infoId
    configMode: { type: String, default: '' },   // 模式
    selectIfCode: { type: String ,default: '' }, // 默认选中的支付接口
    onlyRate: { type: Boolean ,default: false }, // 是否只有费率的模式， true: 只显示费率（一般进件模式选择该方式, 并且配合selectIfCode使用），  false 显示支付接口和保存按钮。 
    showSaveBtn: { type: Boolean ,default: true }, // 是否显示保存按钮， 当向三方申请保存费率申请时，不需要显示。 
  
  })


// 定义所有的类型 
const allWayCodeTypeList = ['WECHAT', 'ALIPAY', 'YSFPAY', 'UNIONPAY', 'DCEPPAY', 'OTHERS']

  
  // 判断是否显示商户的进件费率的配置
  function showMchApplyment(wayCode){
  
    // 运营平台： 服务商的配置费率模式 : 判断是否主动开启
    if(props.configMode == 'mgrIsv'){
        return vdata.mainRateMap[wayCode].applymentSupport == 1
    }
  
    // 其他的需要判断： 是否服务商支持进件。  判断wayCodes中是否支持。
    let obj = vdata.allPaywayMap[wayCode]
    return obj && obj.fixConfig && obj.fixConfig.applymentSupport == 1
  
  }
  
  // 定义响应式数据
  const vdata : any = reactive({
        currentIfCode : '', //当前选择的支付通道
        btnLoading: false, // 按钮loading 
        jeepayPaywayFeeFlag: false, // 是否显示费率组件（用于重新渲染组件）
  
        // 费率设置面板的 table 列
        tableColumns : [],
  
  
        showSetFeeModal: false, //显示统一设置 弹层
        showSetFeeModalMode: '', //设置类型
        showSetFeeModalValue: 0, //设置的费率
        showSetIsOpenValue: true, //设置统一的开关
        
        allPaywayList : [], //费率设置的集合 
        allPaywayMap : {}, // 费率设置的集合 Map
  
        //  key  = ifCode 
        // mainRateMap 表示多个费率值的设置：   ISVCOST,  AGENT,  MCH,  根据传入的不同进行不同结果的返回。 
        mainRateMap: {},
  
        agentdefMap: {}, // 代理商默认费率
        mchapplydefMap: {}, // 商户进件默认费率
  
        readonlyIsvCostRateMap: {}, // 服务商底价（用于显示）
        readonlyParentAgentRateMap: {}, // 上级代理商费率（用于显示）
        readonlyParentDefRateRateMap: {}, // 商户的上级的默认费率（用于读取并赋值到input）
  
        noCheckRuleFlag: false, // 特殊商户， 不进行验证费率规则
  
  
  })
  
  
  // 挂载钩子函数 
  onMounted(() => {
    
    vdata.currentIfCode = '' // 默认不选中
  
    vdata.currentIfCode = props.selectIfCode // 默认接口
  
    // 重置表格
    resetTableColumns()
  
    // 重新渲染配置面板
    if(vdata.currentIfCode){
      reloadRatePanel() 
    }
  
  })
  
  /* 根据不同的类型 显示不同的列表数据  */
  function resetTableColumns(){
  
    // 运营平台配置： 代理商费率， 配置 商户费率， 配置进件信息
    if(props.configMode == 'mgrAgent' || props.configMode == 'mgrMch' || props.configMode == 'mgrApplyment'){
        vdata.tableColumns = [
              {key: 'batch', title: '批量选择', width: '50px' },
              {key: 'wayName', title: '支付产品', width: '110px'  },
              {key: 'readonlyIsvCostRate', title: '服务商底价'  },
              {key: 'readonlyParentAgentRate', title: '上级代理商费率' },
              {key: 'state', title: '是否开通'  },
              {key: 'op', title: '配置信息'},
            ]
  
        if(!$hasAgentEnt()){
          vdata.tableColumns.splice(3, 1) //删除 上级代理商费率 列
        }
  
  
    // 代理商配置商户的费率
    }else if(props.configMode == 'agentMch' || props.configMode == 'agentSubagent' || props.configMode == 'agentApplyment'){
        vdata.tableColumns = [
              {key: 'batch', title: '批量选择', width: '50px' },
              {key: 'wayName', title: '支付产品', width: '110px'  },
              {key: 'readonlyParentAgentRate', title: '我的代理费率' },
              {key: 'state', title: '是否开通'},
              {key: 'op', title: '配置信息' },
            ]
  
    }
    // 代理商配置自己的配置信息
    else if(props.configMode == 'agentSelf'){
        vdata.tableColumns = [
              {key: 'batch', title: '批量选择', width: '50px' },
              {key: 'wayName', title: '支付产品', width: '110px'  },
              {key: 'readonlyParentAgentRate', title: '我的代理费率'  },
              {key: 'op', title: '配置信息' },
            ]
  
    }
    // 服务商底价设置
    else if(props.configMode == 'mgrIsv'){
        vdata.tableColumns = [
              {key: 'batch', title: '批量选择', width: '50px' },
              {key: 'wayName', title: '支付产品', width: '110px'  },
              {key: 'state', title: '是否开通'  },
              {key: 'applymentSupport', title: '进件显示' },
              {key: 'op', title: '配置信息' },
            ]
  
    }
      // 商户自主进件
    else if(props.configMode == 'mchApplyment'){
        vdata.tableColumns = [
              {key: 'wayName', title: '支付产品', width: '270px'  },
              {key: 'op', title: '费率' },
            ]
  
    }
    else{ // 默认使用该方式显示
  
  
    vdata.tableColumns = [
              {key: 'batch', title: '批量选择', width: '70px' },
              {key: 'wayName', title: '支付产品', width: '270px'  },
              {key: 'state', title: '是否开通', width: '120px'  },
              {key: 'op', title: '配置信息' },
            ]
  
  
    }
  
  }
  
  
  // 重置 【费率配置】面板
  async function reloadRatePanel(){
  
    // 数据的重置
    vdata.allPaywayList = [] 
    vdata.allPaywayMap = {}
  
    vdata.mainRateMap= {}
    vdata.agentdefMap= {}
    vdata.mchapplydefMap= {}
    vdata.readonlyIsvCostRateMap = {}
    vdata.readonlyParentAgentRateMap = {}
    vdata.readonlyParentDefRateRateMap = {}
  
    // 当前保存的数据 (DB中的)
    let savedMap : any = {}
  
    //查询当前已经配置的费率 
    await $getRateConfigSavedMapData(props.infoId, props.configMode, vdata.currentIfCode).then((savedMapRes) => {
      savedMap = savedMapRes
    })
  
    // 查询全部支付产品列表 
    await $getRateConfigPayways(props.infoId, props.configMode, vdata.currentIfCode).then((res) => {
  
        res.records.forEach(item => {
  
            item.checked = false // 批量选择， 默认不选中
            vdata.allPaywayList.push(item)
            vdata.allPaywayMap[item.wayCode] = item
            
            // 初始化数据 
            vdata.mainRateMap[item.wayCode] = {
                wayCode: item.wayCode,
                state: 0, // 默认不开通
                applymentSupport: 0, // 进件是否显示
                feeType: 'SINGLE', // 默认单笔费率
                levelList: [], // 阶梯费率数组 
            }
  
            vdata.agentdefMap[item.wayCode] = { // 代理商默认费率  
                wayCode: item.wayCode,
                state: 0, // 默认不开通
                applymentSupport: 0, // 进件是否显示
                feeType: 'SINGLE', // 默认单笔费率
                levelList: [], // 阶梯费率数组 
            }
  
            vdata.mchapplydefMap[item.wayCode] = { // 商户进件默认费率 
                wayCode: item.wayCode,
                state: 0, // 默认不开通
                applymentSupport: 0, // 进件是否显示
                feeType: 'SINGLE', // 默认单笔费率
                levelList: [], // 阶梯费率数组 
            }
  
  
            vdata.readonlyIsvCostRateMap[item.wayCode] = {
                wayCode: item.wayCode,
                state: 0, // 默认不开通
                applymentSupport: 0, // 进件是否显示
                feeType: 'SINGLE', // 默认单笔费率
                levelList: [], // 阶梯费率数组 
            }
  
  
            vdata.readonlyParentAgentRateMap[item.wayCode] = {
                wayCode: item.wayCode,
                state: 0, // 默认不开通
                applymentSupport: 0, // 进件是否显示
                feeType: 'SINGLE', // 默认单笔费率
                levelList: [], // 阶梯费率数组 
            }
  
            vdata.readonlyParentDefRateRateMap[item.wayCode] = {
                wayCode: item.wayCode,
                state: 0, // 默认不开通
                applymentSupport: 0, // 进件是否显示
                feeType: 'SINGLE', // 默认单笔费率
                levelList: [], // 阶梯费率数组 
            }
            
        })
  
        // 服务商底价
        if(savedMap && savedMap.ISVCOST){
          changeList('mainRateMap', savedMap.ISVCOST)
        }
  
        // 代理商费率
        if(savedMap && savedMap.AGENTRATE){
          changeList('mainRateMap', savedMap.AGENTRATE)
        }
  
        // 商户费率 （此上三个 后台返回接口  三选一 ）
        if(savedMap && savedMap.MCHRATE){
          changeList('mainRateMap', savedMap.MCHRATE)
        }
  
  
        // 代理商默认费率
        if(savedMap && savedMap.AGENTDEF){
          changeList('agentdefMap', savedMap.AGENTDEF)
        }
  
        // 商户默认费率
        if(savedMap && savedMap.MCHAPPLYDEF){
          changeList('mchapplydefMap', savedMap.MCHAPPLYDEF)
        }
  
  
        // 服务商底价（用于显示）
        if(savedMap && savedMap.READONLYISVCOST){
          changeList('readonlyIsvCostRateMap', savedMap.READONLYISVCOST)
        }
  
  
        // 上级代理商费率（用于显示）
        if(savedMap && savedMap.READONLYPARENTAGENT){
          changeList('readonlyParentAgentRateMap', savedMap.READONLYPARENTAGENT)
        }
  
        // 上级配置的默认费率（用于显示）
        if(savedMap && savedMap.READONLYPARENTDEFRATE){
          changeList('readonlyParentDefRateRateMap', savedMap.READONLYPARENTDEFRATE)
        }

        // 判断是否为合并模式

      // 遍历所有的 类型 
      for (let wayCodeTypeIndex = 0; wayCodeTypeIndex < allWayCodeTypeList.length; wayCodeTypeIndex++) {

        // 比如 WECHAT ALIPAY 
        let currentWayCodeType = allWayCodeTypeList[wayCodeTypeIndex]


        // 当前类型所有的产品集合 
        let filterPaywayList : any = vdata.allPaywayList.filter(r => r.wayType == currentWayCodeType)
        let filterPaywayListByCodeList : any = []
        filterPaywayList.forEach(r => filterPaywayListByCodeList.push(r.wayCode))


        let mainStr : any = null
        

        // 判断是否合并模式 
        let checkIsMergeFlag = (map, isSetMainStr) => {

          let mergeFlag = true // 是否合并模式 
          let mergeStr : any = null

          Object.values(map).filter( (r :any) => filterPaywayListByCodeList.indexOf(r.wayCode) >= 0).forEach(r => {

            let obj = JSON.parse(JSON.stringify(r))
            obj.wayCode = null

            // 关闭的无需判断， 页面可勾选的数据。 
            if(obj.state != 1){
              return true
            }

            if(mergeStr == null){
              mergeStr = JSON.stringify(obj)
              if(isSetMainStr){ mainStr = JSON.stringify(obj) }
            }

            // 已经是false了 无需判断了。 
            if(mergeFlag){
              mergeFlag = JSON.stringify(obj) == mergeStr
            }

          })

          return mergeFlag

        }

        let mainMergeFlag : any = checkIsMergeFlag(vdata.mainRateMap, true)
        let agentdefMapMergeFlag  : any = checkIsMergeFlag(vdata.agentdefMap, false)
        let mchapplydefMapMergeFlag  : any = checkIsMergeFlag(vdata.mchapplydefMap, false)

        // 合并模式 && 包含数据， filterPaywayListByCodeList为空说明： 该类型没有任何支付产品。 
        if(mainMergeFlag && agentdefMapMergeFlag && mchapplydefMapMergeFlag && filterPaywayListByCodeList.length > 0){

          let defObjStr = JSON.stringify({
                state: 0, // 默认开启
                applymentSupport: 0, // 进件是否显示
                feeType: 'SINGLE', // 默认单笔费率
                levelList: [], // 阶梯费率数组 
          })

          // 合并模式的名称  例如： $$MERGE_FEE_WECHAT
          let mergeModeName = getMergeWayCode(currentWayCodeType)
          vdata.mainRateMap[mergeModeName] = JSON.parse(mainStr || defObjStr)
          vdata.mainRateMap[mergeModeName].wayCode = mergeModeName


          let agentdefList = Object.values(vdata.agentdefMap).filter( (r :any) => filterPaywayListByCodeList.indexOf(r.wayCode) >= 0)
          if(agentdefList.length > 0){
            vdata.agentdefMap[mergeModeName] = JSON.parse(JSON.stringify(agentdefList[0]))
            vdata.agentdefMap[mergeModeName].wayCode = mergeModeName
          }else{ // 存量数据没有配置过
            vdata.agentdefMap[mergeModeName] = JSON.parse(mainStr || defObjStr)
            vdata.agentdefMap[mergeModeName].wayCode = mergeModeName
          }


          let mchapplydefList = Object.values(vdata.mchapplydefMap).filter( (r :any) => filterPaywayListByCodeList.indexOf(r.wayCode) >= 0)
          if(mchapplydefList.length > 0){
            vdata.mchapplydefMap[mergeModeName] = JSON.parse(JSON.stringify(mchapplydefList[0]))
            vdata.mchapplydefMap[mergeModeName].wayCode = mergeModeName
          }else{ // 存量数据没有配置过
            vdata.mchapplydefMap[mergeModeName] = JSON.parse(mainStr || defObjStr)
            vdata.mchapplydefMap[mergeModeName].wayCode = mergeModeName
          }


          let readonlyIsvCostRateMapList = Object.values(vdata.readonlyIsvCostRateMap).filter( (r :any) => filterPaywayListByCodeList.indexOf(r.wayCode) >= 0)
          if(readonlyIsvCostRateMapList.length > 0){
            vdata.readonlyIsvCostRateMap[mergeModeName] = JSON.parse(JSON.stringify(readonlyIsvCostRateMapList[0]))
            vdata.readonlyIsvCostRateMap[mergeModeName].wayCode = mergeModeName
          }else{ // 存量数据没有配置过
            vdata.readonlyIsvCostRateMap[mergeModeName] = JSON.parse(mainStr || defObjStr)
            vdata.readonlyIsvCostRateMap[mergeModeName].wayCode = mergeModeName
          }


          let readonlyParentAgentRateMapList = Object.values(vdata.readonlyParentAgentRateMap).filter( (r :any) => filterPaywayListByCodeList.indexOf(r.wayCode) >= 0)
          if(readonlyParentAgentRateMapList.length > 0){
            vdata.readonlyParentAgentRateMap[mergeModeName] = JSON.parse(JSON.stringify(readonlyParentAgentRateMapList[0]))
            vdata.readonlyParentAgentRateMap[mergeModeName].wayCode = mergeModeName
          }else{ // 存量数据没有配置过
            vdata.readonlyParentAgentRateMap[mergeModeName] = JSON.parse(mainStr || defObjStr)
            vdata.readonlyParentAgentRateMap[mergeModeName].wayCode = mergeModeName
          }

          
        // 判断合并模式 结束
        }
          

      // 遍历所有的 类型  结束
      }


      console.log(vdata)
      
    // http 查询全部支付产品列表  结束
    })
  
  }
  
  
  // 保存按钮 
  function onSubmit(){
  
    let reqPaywayFeeList = getReqPaywayFeeList()
    if(!reqPaywayFeeList){ // 报错
        return false 
    }
  
    // 请求对象
    let reqObject = {infoId: props.infoId, ifCode: vdata.currentIfCode, configMode: props.configMode, noCheckRuleFlag: vdata.noCheckRuleFlag ? 1: 0 }
    Object.assign(reqObject, reqPaywayFeeList) // 合并对象
  
    $saveRateConfig(reqObject).then((res) => {
      $infoBox.message.success('保存成功')
    })
  }
  
  
  function batchChecked(wayType, checked){
    vdata.allPaywayList.filter( r => ((wayType == 'ALL' || r.wayType == wayType) ) ).forEach(element => {
      element.checked = checked
    })
  }
  
  
  // 点击 批量设置弹层的确认按钮 
  function handleOkFunc(){
  
  vdata.allPaywayList.filter( r => r.checked).forEach(element => {
  
        let iele = vdata[vdata.showSetFeeModalMode][element.wayCode]
        iele.feeType = 'SINGLE'
        iele.feeRate = vdata.showSetFeeModalValue
        iele.state = vdata.showSetIsOpenValue ? 1 : 0 // 是否开启
    })
  
    // 关闭弹层
    vdata.showSetFeeModal = false 
  
  }
  
  
  // 显示弹层( mode = 修改的mode )
  function showSetFeeModalFunc(mode){
  
  if(vdata.allPaywayList.filter(r => r.checked).length <= 0){
    return $infoBox.message.error('请选择需要操作的行')
  }
  
    vdata.showSetFeeModalMode = mode
    vdata.showSetFeeModalValue = 0
    vdata.showSetIsOpenValue = true
    vdata.showSetFeeModal = true
  }
  
  
  // 读取默认费率
  function resetDefRate(){
  
  let vals : any = Object.values(vdata.mainRateMap)
  
    vals.forEach(element => {
  
          element.state = 0
          element.feeType = 'SINGLE'
          delete element.feeRate
          element.levelList = []
  
          let copyObject = vdata.readonlyParentDefRateRateMap[element.wayCode]
          if(copyObject){
              Object.assign(element, JSON.parse(JSON.stringify(copyObject)))
          }
          
    })
  
  }
  
  
  // 更改当前可视化的值 （此时已经查询到了全部支付方式了）
  // savedMap : 当前DB保存的数据
  function changeList(mode, savedMap){
  
    // 全部支付方式
    let valList : any = Object.values(vdata[mode])
  
    valList.forEach(element => {
  
      // 数据初始化操作
      element.feeType = 'SINGLE'
      delete element.feeRate
      delete element.minFee
      delete element.maxFee
      element.levelList = []
  
      let record = savedMap[element.wayCode] || {}
  
      //复制到数组中 
      Object.assign(element, record)
      element.checked = false
  
      element.state = savedMap[element.wayCode] ? 1 : 0 //默认开通
  
      // 明确关闭
      if(savedMap[element.wayCode] && savedMap[element.wayCode].state === 0){
          element.state = 0
      }
      
      // 转换费率和金额格式
  
      if(typeof(element.feeRate) == 'number'){
          element.feeRate = Number.parseFloat((element.feeRate * 100).toFixed(4))
      }
  
      if(typeof(element.maxFee) == 'number'){
          element.maxFee = Number.parseFloat((element.maxFee / 100).toFixed(2))
      }
  
      if(typeof(element.minFee) == 'number'){
          element.minFee = Number.parseFloat((element.minFee / 100).toFixed(2))
      }
  
      if(element.levelList){
          element.levelList.forEach(levelItem => {
              if(typeof(levelItem.feeRate) == 'number'){
                  levelItem.feeRate = Number.parseFloat((levelItem.feeRate * 100).toFixed(4))
              }
  
              if(typeof(levelItem.maxFee) == 'number'){
                  levelItem.maxFee = Number.parseFloat((levelItem.maxFee / 100).toFixed(2))
              }
  
              if(typeof(levelItem.minFee) == 'number'){
                  levelItem.minFee = Number.parseFloat((levelItem.minFee / 100).toFixed(2))
              }
          })
      }
  
      // 贷记卡的金额回显
      if(element.creditCardPaywayFee){
        
        if(typeof(element.creditCardPaywayFee.feeRate) == 'number'){
            element.creditCardPaywayFee.feeRate = Number.parseFloat((element.creditCardPaywayFee.feeRate * 100).toFixed(4))
        }
  
        if(typeof(element.creditCardPaywayFee.maxFee) == 'number'){
            element.creditCardPaywayFee.maxFee = Number.parseFloat((element.creditCardPaywayFee.maxFee / 100).toFixed(2))
        }
  
        if(typeof(element.creditCardPaywayFee.minFee) == 'number'){
            element.creditCardPaywayFee.minFee = Number.parseFloat((element.creditCardPaywayFee.minFee / 100).toFixed(2))
        }
  
        if(element.creditCardPaywayFee.levelList){
            element.creditCardPaywayFee.levelList.forEach(levelItem => {
                if(typeof(levelItem.feeRate) == 'number'){
                    levelItem.feeRate = Number.parseFloat((levelItem.feeRate * 100).toFixed(4))
                }
  
                if(typeof(levelItem.maxFee) == 'number'){
                    levelItem.maxFee = Number.parseFloat((levelItem.maxFee / 100).toFixed(2))
                }
  
                if(typeof(levelItem.minFee) == 'number'){
                    levelItem.minFee = Number.parseFloat((levelItem.minFee / 100).toFixed(2))
                }
            })
        }
      }
  
        
    })
  }
  
  // 获取请求数据的对象格式 (包含了验证规则)
  // 返回格式： { ISVCOST: []   AGENTDEF:[]   MCHAPPLYDEF:[] }
  function getReqPaywayFeeList(){
  
    let mainRateList = getReqPaywayFeeListByList(Object.values(vdata.mainRateMap))
  
    if(typeof(mainRateList) != 'object'){
        return false
    }
  
    let agentdefList = getReqPaywayFeeListByList(Object.values(vdata.agentdefMap))
    if(typeof(agentdefList) != 'object'){
        return false
    }
  
    let mchapplydefList = getReqPaywayFeeListByList(Object.values(vdata.mchapplydefMap), true)
    if(typeof(mchapplydefList) != 'object'){
        return false
    }
  
    if(props.configMode == 'mgrIsv'){
        return { ISVCOST: mainRateList, AGENTDEF: agentdefList, MCHAPPLYDEF: mchapplydefList  }
  
    }else if(props.configMode == 'mgrAgent'){
        return { AGENTRATE: mainRateList, AGENTDEF: agentdefList, MCHAPPLYDEF: mchapplydefList  }
  
    }else if(props.configMode == 'mgrMch' || props.configMode == 'agentMch' || props.configMode == 'mgrApplyment' || props.configMode == 'mchApplyment' || props.configMode == 'agentApplyment' ){
        return { MCHRATE: mainRateList }
        
    }else if(props.configMode == 'agentSubagent'){
        return { AGENTRATE: mainRateList }
        
    }else if(props.configMode == 'agentSelf'){
        return { AGENTDEF: agentdefList, MCHAPPLYDEF: mchapplydefList  }
  
    }else if(props.configMode == 'mchSelfApp1'){ // 普通商户的设置
        return { MCHRATE: mainRateList }
    }
  
  
  }
  
  // element(原始数据) -->  obj（新对象的数据）
  // 当前一切正常，返回 true
  function levelFeeElementConvertObj(obj, element){
  
      if(typeof(element.minFee) != 'number'){
        return $infoBox.message.error('阶梯费率请填入保底费用')
      }
      if(typeof(element.maxFee) != 'number'){
        return $infoBox.message.error('阶梯费率请填入封顶费用')
      }
  
      obj.minFee = Number.parseInt(element.minFee * 100 + '')
      obj.maxFee = Number.parseInt(element.maxFee * 100 + '')
  
  
      let levelList :any = []
      for (let y = 0; y < element.levelList.length; y++) {
          let levelItem =  element.levelList[y]
  
          let levelCopy :any = {}
  
          if(typeof(levelItem.feeRate) != 'number' || levelItem.feeRate <= 0){
              return $infoBox.message.error('请录入阶梯费率')
          }
  
          if(typeof(levelItem.minFee) != 'number'){
              return $infoBox.message.error('阶梯费率请填入金额区间值')
          }
          if(typeof(levelItem.maxFee) != 'number'){
              return $infoBox.message.error('阶梯费率请填入金额区间值')
          }
  
          levelCopy.feeRate = Number.parseFloat((levelItem.feeRate / 100).toFixed(4))
          levelCopy.minFee = Number.parseInt(levelItem.minFee * 100 + '')
          levelCopy.maxFee = Number.parseInt(levelItem.maxFee * 100 + '')
          levelList.push(levelCopy)
      }
  
      obj.levelList = levelList
      if(obj.levelList.length <= 0 ){
          return $infoBox.message.error('阶梯费率请至少包含一个价格区间')
      }
  
      return true
  }
  
  
// 拼接合并费率的唯一编号。 
function getMergeWayCode(wayType){
  return '$$MERGE_FEE_' + wayType
}


  // 通用获取费率配置信息
  function getReqPaywayFeeListByList(list, filterApplymentSupport = false){
  
    let result : any = []


    // 遍历所有的 类型 
    for (let wayCodeTypeIndex = 0; wayCodeTypeIndex < allWayCodeTypeList.length; wayCodeTypeIndex++) {

      // 判断是否是 合并模式。 
      let currentWayCodeType = allWayCodeTypeList[wayCodeTypeIndex]

      // 合并模式的名称  例如： $$MERGE_FEE_WECHAT
      let mergeModeName = getMergeWayCode(currentWayCodeType)

      let mergeMode :any = null
      let filterList = list.filter(r => (r.wayCode.indexOf(mergeModeName) >= 0 ) )
      if(filterList.length > 0){
        mergeMode = filterList[0]
      }

      // 所有需要合并开通的类型集合  (当前 分类 ) 这里  不包含：  $$MERGE_FEE_WECHAT 合并类型 
      let mergeModeWayCodeList : any = []
      if(mergeMode){
          Object.values(vdata.mainRateMap).forEach(r => {
            let rr : any = r
            if(rr.state == 1 && rr.wayCode != mergeModeName && vdata.allPaywayMap[rr.wayCode] && currentWayCodeType == vdata.allPaywayMap[rr.wayCode].wayType) {
              mergeModeWayCodeList.push(rr.wayCode)
            }
          })
      }

      // 所有开通 
      // 1. 添加 : vdata.allPaywayMap[r.wayCode]  仅判断仅获取支持的接口（避免 服务商设置了， 又关闭掉了这种情况。    2. 此逻辑可删除， 因为初始化mainRateList是来自支持的接口的。  )

      // 默认不包含该 合并变量  
      let supportArray = list.filter(r => (r.state == 1 && r.wayCode != mergeModeName && vdata.allPaywayMap[r.wayCode] && vdata.allPaywayMap[r.wayCode].wayType == currentWayCodeType) )

      // 合并模式  就一条记录
      if(mergeMode){
        supportArray = list.filter(r => (r.wayCode == mergeModeName && r.state == 1) )
      }

      console.log(currentWayCodeType, supportArray)

      // 遍历 supportArray
      for (let index = 0; index < supportArray.length; index++) {

          const element = supportArray[index]

            // 只包含进件的数据 && 当前数据行不支持进件  默认费率无法保存， 旧的逻辑。 
          // if(filterApplymentSupport && !showMchApplyment(element.wayCode)){
          //   continue
          // }

          let obj : any = {}

          obj.wayCode = element.wayCode
          obj.feeType = element.feeType
          obj.state = element.state
          obj.applymentSupport = element.applymentSupport

          // 以下为： state = true的情况
      
          //单笔费率值
          if(element.feeType == 'SINGLE'){
            if( typeof(element.feeRate) != 'number' || element.feeRate < 0){
                return $infoBox.message.error('费率值不可小于0')
            }
            obj.feeRate = Number.parseFloat((element.feeRate / 100).toFixed(4))
        
          }else{ // 阶梯费率
                
                let convertResult = levelFeeElementConvertObj(obj, element)
                if(! (convertResult === true)){ // 出现异常
                  return false
                }

                // 包含 信用卡的配置项
                if(element.creditCardPaywayFee){
                  let creditCardPaywayFeeObj = {}
                  let convertResult2 = levelFeeElementConvertObj(creditCardPaywayFeeObj, element.creditCardPaywayFee)
                  if(! (convertResult2 === true) ){ // 出现异常
                    return false
                  }

                  obj.creditCardPaywayFee = creditCardPaywayFeeObj
                }

          }

          // 合并模式， 将勾选的列添加上。 
          if(mergeMode){

            mergeModeWayCodeList.forEach(wayCode => {

              let item = JSON.parse(JSON.stringify(obj))
              item.wayCode = wayCode
              result.push(item)
            })

          }else{
            result.push(obj)
          }
          
      //  // 遍历 supportArray  结束 
      }

    // // 遍历所有的 类型  结束 
    }

    return result
  }
  
  
  /** 获取到： 商户的费率值 （一般用作进件时的设置费率值）  */
  /** 还有， 盛付通，申请费率调整时需要  */
  function getReqMchRatePaywayFeeList(){
  
    let reqPaywayFeeList = getReqPaywayFeeList()
  
    if(!reqPaywayFeeList){ // 报错
        return false 
    }
  
    return reqPaywayFeeList['MCHRATE']
  }
  
  
  // 判断是否开通了某个支付产品 
  function hasApplymentWaycode(wayCode){
    return ( vdata.mainRateMap[wayCode] && vdata.mainRateMap[wayCode].state == 1 ) 
  }
  
  
  // 读取默认费率
  function setParentRateBtnFunc(wayCode){
  
    // 判断上级的费率是否可用
    let checkFunc = (rate) => {
  
      if(!rate){
        return null
      }
  
      // 单笔
      if(rate.feeType == 'SINGLE' && typeof(rate.feeRate) != 'undefined'){
        return rate
      }
  
      // 阶梯
      if(rate.feeType == 'LEVEL' && rate.levelList && rate.levelList.length > 0 && rate.levelList[0].feeRate ){
        return rate
      }
  
      return null
    }
  
    let rate = checkFunc(vdata.readonlyParentDefRateRateMap[wayCode]) ||  checkFunc(vdata.readonlyParentAgentRateMap[wayCode]) ||  checkFunc(vdata.readonlyIsvCostRateMap[wayCode])
  
    if(rate){
  
      // 只取到基础费率数据
      Object.assign(vdata.mainRateMap[wayCode], JSON.parse(JSON.stringify({
        feeType: rate.feeType,
        feeRate: rate.feeRate,
        levelList: rate.levelList,
        maxFee: rate.maxFee,
        minFee: rate.minFee,
        creditCardPaywayFee: rate.creditCardPaywayFee,
      })))
  
      return false
    }
  }
  
  function isShowsetParentRateBtn(){
  
     // 设置服务商底价 , 代理商自己的页面, 普通商户 , 商户的进件页面 不需要显示
    if(props.configMode == 'mgrIsv' || props.configMode == 'agentSelf' || props.configMode == 'mchSelfApp1' || props.configMode == 'mchApplyment'){
      return false
    }
  
    return true
  }


  // 向子组件注入： vdata全部数据  parent data 
provide('pvdata', computed( ()=> vdata) )
  
  
  defineExpose({getReqMchRatePaywayFeeList, hasApplymentWaycode})
  
  
  </script>
  
  <style lang="less" scoped>
  .drawer {
    /* position: relative; */
    border-radius: 10px;
    background: #fff;
    border-radius: 10px;
    padding: 30px;
    padding-bottom: 0;
  }
  </style>
  