import com.dderp.common.api.BusinessExecutor
import com.dderp.common.api.ERPLockDataService
import com.dderp.common.api.NoSqlKeysService
import com.dderp.common.datas.ERPModule
import com.dderp.common.datas.RedisKeys
import com.dderp.common.entity.base.InvokeCallParams
import com.dderp.common.entity.base.InvokeCallResult
import com.dySweetFishPlugin.sql.dao.OperatorWait
import com.sweetfish.convert.json.JsonConvert
import com.sweetfish.service.RetResult
import groovy.json.JsonSlurper
import org.apache.commons.lang3.StringUtils
import org.apache.logging.log4j.LogManager
import org.apache.logging.log4j.Logger

import javax.annotation.Resource

class BE_Express_OrderStatusInvoke_SFTC implements BusinessExecutor<InvokeCallParams, InvokeCallResult> {

    private final Logger logger = LogManager.getLogger(this.getClass().getSimpleName())

    @Resource
    JsonConvert jsonConvert

    @Resource
    ERPLockDataService lockDataService

    @Resource
    NoSqlKeysService keysService

    @Override
    String scriptName() {
        return "顺丰同城数据回调"
    }

    @Override
    ERPModule module() {
        return ERPModule.EXPRESS_API
    }

    @Override
    OperatorWait getAWait() {
        return OperatorWait.ASNYC
    }

    @Override
    RetResult<InvokeCallParams> beforeExecute(InvokeCallParams source) {
        //此回调post的数据看着没有子表，直接用groovy自带的json即可，如果有子表，还是应该建立一个类进行转换

        //锁定下数据，防止重复提交
        def jsonSlurper = new JsonSlurper()
        def invokeOrder = jsonSlurper.parseText(source.params)

        String urlIndex = invokeOrder["url_index"] as String

        //这里除了店铺授权和店铺取消授权，其它都是订单，if-else先写着
        if (StringUtils.equalsIgnoreCase("bindnotify", urlIndex)) {
            //店铺授权回调
            String shopId = invokeOrder["shop_id"] as String
            if (lockDataService.hLockAdd(shopId, RedisKeys.KEY_ERP_WORKING_SF_STORE, source.supplierCode) > 1) {
                return RetResult.<InvokeCallParams> errorT().retinfo(shopId + "提交工作中，请稍后刷新即可，无需重复操作")
            }
        } else if (StringUtils.equalsIgnoreCase("cancelbindnotify", urlIndex)) {
            //店铺取消授权回调
            String shopId = invokeOrder["shop_id"] as String
            if (lockDataService.hLockAdd(shopId, RedisKeys.KEY_ERP_WORKING_SF_STORE, source.supplierCode) > 1) {
                return RetResult.<InvokeCallParams> errorT().retinfo(shopId + "提交工作中，请稍后刷新即可，无需重复操作")
            }
        } else {
            String invokeOrderId = invokeOrder["sf_order_id"] as String
            if (lockDataService.hLockAdd(invokeOrderId, RedisKeys.KEY_ERP_WORKING_SF_ORDER, source.supplierCode) > 1) {
                return RetResult.<InvokeCallParams> errorT().retinfo(invokeOrderId + "提交工作中，请稍后刷新即可，无需重复操作")
            }
        }

        return RetResult.<InvokeCallParams> successT().result(source)
    }

    @Override
    void afterExecute(boolean executeError, InvokeCallParams source, InvokeCallResult dest) {
        def jsonSlurper = new JsonSlurper()
        def invokeOrder = jsonSlurper.parseText(source.params)

        String urlIndex = invokeOrder["url_index"] as String
        if (StringUtils.equalsIgnoreCase("bindnotify", urlIndex)) {
            //店铺授权回调
            String shopId = invokeOrder["shop_id"] as String
            lockDataService.hLockDel(shopId, RedisKeys.KEY_ERP_WORKING_SF_STORE, source.supplierCode)
        } else if (StringUtils.equalsIgnoreCase("cancelbindnotify", urlIndex)) {
            //店铺取消授权回调
            String shopId = invokeOrder["shop_id"] as String
            lockDataService.hLockDel(shopId, RedisKeys.KEY_ERP_WORKING_SF_STORE, source.supplierCode)
        } else {
            String invokeOrderId = invokeOrder["sf_order_id"] as String
            lockDataService.hLockDel(invokeOrderId,RedisKeys.KEY_ERP_WORKING_SF_ORDER, source.supplierCode)
        }
    }

    RetResult<InvokeCallResult> execute(InvokeCallParams source) {
        def jsonSlurper = new JsonSlurper()
        def invokeOrder = jsonSlurper.parseText(source.params)

        logger.info(invokeOrder["url_index"])
        logger.info(invokeOrder["sf_order_id"])
        logger.info(invokeOrder["operator_name"])

        return RetResult.<InvokeCallResult> successT().result(
                InvokeCallResult.success()
        )
    }
}