package com.yami.trading.api.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yami.trading.api.service.UserCacheService;
import com.yami.trading.bean.c2c.C2cOrder;
import com.yami.trading.bean.model.*;
import com.yami.trading.bean.rate.domain.ExchangeRate;
import com.yami.trading.bean.syspara.domain.Syspara;
import com.yami.trading.common.constants.Constants;
import com.yami.trading.common.constants.RedisKeys;
import com.yami.trading.common.domain.Result;
import com.yami.trading.common.exception.YamiShopBindException;
import com.yami.trading.common.util.*;
import com.yami.trading.security.common.util.SecurityUtils;
import com.yami.trading.security.common.manager.PasswordManager;
import com.yami.trading.service.*;
import com.yami.trading.service.c2c.C2cAdvertService;
import com.yami.trading.service.c2c.C2cOrderService;
import com.yami.trading.service.c2c.C2cPaymentMethodService;
import com.yami.trading.service.c2c.C2cTranslateService;
import com.yami.trading.service.chat.otc.OtcOnlineChatMessageServiceImpl;
import com.yami.trading.service.rate.ExchangeRateService;
import com.yami.trading.service.syspara.SysparaService;
import com.yami.trading.service.user.UserDataService;
import com.yami.trading.service.user.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;

import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;

@RestController
@RequestMapping("api/c2cOrder")
@Api(tags = "C2C订单")
public class ApiBankCardController {
    @Autowired
    C2cOrderService c2cOrderService;
    @Autowired
    UserService userService;
    @Autowired
    UserCacheService userCacheService;
    @Autowired
    SysparaService sysparaService;
    @Autowired
    WalletService walletService;
    @Autowired
    C2cPaymentMethodService c2cPaymentMethodService;
    @Autowired
    WithdrawService withdrawService;
    @Autowired
    private PasswordManager passwordManager;
    @Autowired
    SessionTokenService sessionTokenService;
    @Autowired
    C2cAdvertService c2cAdvertService;
    @Autowired
    HighLevelAuthRecordService highLevelAuthRecordService;
    @Autowired
    UserDataService userDataService;
    @Autowired
    RedisTemplate redisTemplate;
    @Autowired
    RealNameAuthRecordService realNameAuthRecordService;
    @Autowired
    ExchangeRateService exchangeRateService;
    @Autowired
    C2cTranslateService c2cTranslateService;
    @Autowired
    OtcOnlineChatMessageServiceImpl otcOnlineChatMessageService;
    // TODO: 2023/4/17

    /**
     * 首次进入下单页面，传递session_token
     */
    @ApiOperation("首次进入下单页面，传递session_token")
    @PostMapping("orderOpen")
    public Result<Map<String, Object>> order_open() {
        String partyId = SecurityUtils.getUser().getUserId();
        String session_token = this.sessionTokenService.savePut(partyId);
//        Map<String, C2cPaymentMethod> cpmMap = this.c2cPaymentMethodService.getByPartyId("2c948a8282920a9f01829270bcac0000");
        Map<String, C2cPaymentMethod> cpmMap = this.c2cPaymentMethodService.getByPartyId(partyId);

        if (null == cpmMap || 0 == cpmMap.size()) {
            // TODO: 2023/4/16
            throw new YamiShopBindException("支付方式不存在");
        }
        List<String> cpmList = new ArrayList<String>();
        for (String key : cpmMap.keySet()) {
            cpmList.add(key);
        }
        Map<String, Object> data = new HashMap<String, Object>();
        data.put("session_token", session_token);
        data.put("gf_payment_method_id", cpmList.get(0));
        return Result.succeed(data);
    }

    private String verif(String direction, String nationality, String currency, String payment_method_id, String coin_amount, String img) {
        if (StringUtils.isEmptyString(direction) || !Arrays.asList("recharge", "withdraw").contains(direction)) {
            return "充值或提现不正确";
        }
        Map<String, String> currencyMap = this.c2cPaymentMethodService.getCurrencyMap();
        if (StringUtils.isEmptyString(currency) || null == currencyMap || (null != currencyMap && !currencyMap.containsKey(currency))) {
            return "支付币种不正确";
        }
        if (StringUtils.isEmptyString(payment_method_id)) {
            return "支付方式不正确";
        }
        if (StringUtils.isEmptyString(coin_amount) || !StringUtils.isDouble(coin_amount) || Double.valueOf(coin_amount).doubleValue() <= 0) {
            return "交易数量不正确";
        }
        if ("recharge".equals(direction)) {
            if (StringUtils.isEmptyString(nationality)) {
                return "国家/地区不正确";
            }
            // 银行卡充值是否强制需要上传图片，需要true,不需要false
            boolean bank_card_recharge_must_need_img = this.sysparaService.find("bank_card_recharge_must_need_img").getBoolean();
            if (bank_card_recharge_must_need_img) {
                if (StringUtils.isEmptyString(img)) {
                    return "请上传图片";
                }
            }
        }
        return null;
    }

    private void checkWithdrawLimit(User user, RealNameAuthRecord realNameAuthRecord, double withdrawVolumn) {
        double limit = 0d;
        // 特殊人员不受限制(只有在周提现限制开启后有效)
        String unLimitUid = this.sysparaService.find("withdraw_week_unlimit_uid").getSvalue();
        if (StringUtils.isNotEmpty(unLimitUid)) {
            String[] unLimitUisArr = unLimitUid.split(",");
            if (Arrays.asList(unLimitUisArr).contains(user.getUserCode())) {
                return;
            }
        }
//		if (kycHighLevel.getStatus() == 2) {
//			// 基础认证可提现额度
//			limit = sysparaService.find("withdraw_week_limit_kyc_high").getDouble();
//		} else
        if (realNameAuthRecord.getStatus() == 2) {
            // 高级基础认证每周可提现额度
            limit = this.sysparaService.find("withdraw_week_limit_kyc").getDouble();
        }
        if (limit > 0) {
            // 已用额度
            double weekWithdraw = this.weekWithdraw(user.getUserId());
            if (Arith.add(weekWithdraw, withdrawVolumn) > limit) {
                throw new YamiShopBindException("提现不得大于限额");
            }
        }
    }

    /**
     * 当周已使用额度
     */
    public double weekWithdraw(String partyId) {
        Map<String, UserData> map = this.userDataService.cacheByPartyId(partyId);
        Date now = new Date();
        String endTime = DateUtils.getDateStr(new Date());
        String startTime = DateUtils.getDateStr(DateUtils.addDay(now, -6));
        // 一周内已用额度
        double withdrawMoney = this.withdrawMoney(map, startTime, endTime);
        return withdrawMoney;
//		double remain = Arith.sub(maxLimit, withdrawMoney);
//		if (Arith.add(withdrawMoney, withdrawVolumn) > maxLimit) {
//			throw new BusinessException("提现不得大于限额");
//		}
    }

    /**
     * 时间范围内的充值总额
     */
    private double withdrawMoney(Map<String, UserData> datas, String startTime, String endTime) {
        if (datas == null || datas.isEmpty()) {
            return 0;
        }
        double userWithdraw = 0;
        for (Map.Entry<String, UserData> valueEntry : datas.entrySet()) {
            UserData userdata = valueEntry.getValue();
            Date time = userdata.getCreateTime();
            if (!StringUtils.isNullOrEmpty(startTime)) {
                Date startDate = DateUtils.toDate(startTime, DateUtils.DF_yyyyMMdd);
                // 开始-数据时间
                int intervalDays = DateUtils.getIntervalDaysByTwoDate(startDate, time);
                if (intervalDays > 0) {
                    // 开始>数据时间 ，则过滤
                    continue;
                }
            }
            if (!StringUtils.isNullOrEmpty(endTime)) {
                Date endDate = DateUtils.toDate(endTime, DateUtils.DF_yyyyMMdd);
                // 结束-数据时间
                int intervalDays = DateUtils.getIntervalDaysByTwoDate(endDate, time);
                if (intervalDays < 0) {
                    // 结束<数据时间
                    continue;
                }
            }
            userWithdraw = Arith.add(userdata.getWithdraw(), userWithdraw);
        }
        return userWithdraw;
    }

    /**
     * 银行卡充值/提现申请
     * <p>
     * safeword 资金密码
     * session_token 防重复提交
     * direction 充值或提现：recharge充值/withdraw提现
     * nationality 国家/地区
     * currency 支付币种
     * payment_method_id 支付方式ID：充值为官方收款方式ID，提现为用户收款方式ID
     * coin_amount 交易数量
     * img 付款凭证
     */
    @PostMapping("apply")
    @ApiOperation("银行卡充值/提现申请")
    public Result apply(@RequestParam String safeword, String session_token,
                                String direction, String nationality, String currency, String payment_method_id, String coin_amount,
                                String img) {
        String error = this.verif(direction, nationality, currency, payment_method_id, coin_amount, img);
        if (!StringUtils.isNullOrEmpty(error)) {
            throw new YamiShopBindException(error);
        }
        double coin_amount_double = Double.valueOf(coin_amount).doubleValue();
        String userId = SecurityUtils.getUser().getUserId();
        Object object = this.sessionTokenService.cacheGet(session_token);
        this.sessionTokenService.del(session_token);
        if (null == object || !userId.equals((String) object)) {
            throw new YamiShopBindException("请稍后再试");
        }
        String partyId = SecurityUtils.getUser().getUserId();
        if (null == partyId) {
            throw new YamiShopBindException("请重新登录");
        }
        User party = userService.getById(partyId);
        if (Constants.SECURITY_ROLE_TEST.equals(party.getRoleName())) {
            throw new YamiShopBindException("无权限");
        }
        if (!party.isEnabled()) {
            throw new YamiShopBindException("用户已锁定");
        }
        // 手续费
        double fee = 0;
        if ("withdraw".equals(direction)) {
            // 提现
            // 提现是否需要资金密码
            Syspara pSyspara = this.sysparaService.find("withdraw_need_safeword");
            String withdraw_need_safeword = "true";
            if(pSyspara!=null){
                withdraw_need_safeword = pSyspara.getSvalue();
            }
            if (StringUtils.isEmptyString(withdraw_need_safeword)) {
                throw new YamiShopBindException("System Parameter Error");
            }
            if ("true".equals(withdraw_need_safeword)) {
                if (StringUtils.isEmptyString(safeword)) {
                    throw new YamiShopBindException("The fund password cannot be blank");
                }
                if (safeword.length() < 6 || safeword.length() > 12) {
                    throw new YamiShopBindException("The fund password must be 6-12 digits");
                }
                userService.checkLoginSafeword(userId, safeword);
            }
            RealNameAuthRecord party_kyc = realNameAuthRecordService.getByUserId(partyId);
            if (party_kyc==null){
                party_kyc=new RealNameAuthRecord();
            }
            if (!(party_kyc.getStatus() == 2) && "true".equals(this.sysparaService.find("withdraw_by_kyc").getSvalue())) {
                throw new YamiShopBindException("无权限");
            }
            HighLevelAuthRecord party_kycHighLevel = highLevelAuthRecordService.findByUserId(partyId);
            if (party_kycHighLevel==null){
                party_kycHighLevel=new  HighLevelAuthRecord();
            }
            double withdraw_by_high_kyc = Double.valueOf(this.sysparaService.find("withdraw_by_high_kyc").getSvalue());
            if (withdraw_by_high_kyc > 0 && coin_amount_double > withdraw_by_high_kyc && !(party_kycHighLevel.getStatus() == 2)) {
                throw new YamiShopBindException("请先通过高级认证");
            }
//                if (!party.getWithdraw_authority()) {
//                    throw new BusinessException(1, "无权限");
//                }
            // 手续费(USDT) 提现手续费类型，fixed是单笔固定金额，rate是百分比，part是分段
            String withdraw_fee_type = this.sysparaService.find("withdraw_fee_type").getSvalue();
            // fixed单笔固定金额 和 rate百分比 的手续费数值
            double withdraw_fee = Double.valueOf(this.sysparaService.find("withdraw_fee").getSvalue());
            if ("fixed".equals(withdraw_fee_type)) {
                fee = withdraw_fee;
            }
            if ("rate".equals(withdraw_fee_type)) {
                withdraw_fee = Arith.div(withdraw_fee, 100);
                fee = Arith.mul(coin_amount_double, withdraw_fee);
            }
            if ("part".equals(withdraw_fee_type)) {
                // 提现手续费part分段的值
                String withdraw_fee_part = this.sysparaService.find("withdraw_fee_part").getSvalue();
                String[] withdraw_fee_parts = withdraw_fee_part.split(",");
                for (int i = 0; i < withdraw_fee_parts.length; i++) {
                    double part_amount = Double.valueOf(withdraw_fee_parts[i]);
                    double part_fee = Double.valueOf(withdraw_fee_parts[i + 1]);
                    if (coin_amount_double <= part_amount) {
                        fee = part_fee;
                        break;
                    }
                    i++;
                }
            }
            String withdraw_limit = this.sysparaService.find("withdraw_limit").getSvalue();
            if (coin_amount_double < Double.valueOf(withdraw_limit)) {
                throw new YamiShopBindException("提现不得小于限额");
            }
            String withdraw_limit_max = this.sysparaService.find("withdraw_limit_max").getSvalue();
            if (coin_amount_double > Double.valueOf(withdraw_limit_max)) {
                throw new YamiShopBindException("提现不得大于限额");
            }
            // 检测银行卡用户当日提现次数
            Object obj = this.sysparaService.find("bank_card_withdraw_limit_num");
            if (null != obj) {
                double bank_card_withdraw_limit_num = Double.valueOf(this.sysparaService.find("bank_card_withdraw_limit_num").getSvalue());
                List<C2cOrder> c2cOrders =null;

                      //  this.c2cOrderService.findByPartyIdAndToday(partyId, C2cOrder.DIRECTION_WITHDRAW, null);

                if (bank_card_withdraw_limit_num > 0 && c2cOrders != null) {
                    if (c2cOrders.size() >= bank_card_withdraw_limit_num) {
                        throw new YamiShopBindException("当日可提现次数不足");
                    }
                }
            }
            // 是否在当日提现时间内
            SimpleDateFormat sdf = new SimpleDateFormat();
            sdf.applyPattern("HH:mm:ss");
            Date date = new Date();
            String withdraw_limit_time = this.sysparaService.find("withdraw_limit_time").getSvalue();
            if (StringUtils.isNotEmpty(withdraw_limit_time)) {
                String[] withdraw_time = withdraw_limit_time.split("-");
                String dateString = sdf.format(date);
                if (dateString.compareTo(withdraw_time[0]) < 0 || dateString.compareTo(withdraw_time[1]) > 0) {
                    throw new YamiShopBindException("不在可提现时间内");
                }
            }
            // 周提现额度限制开关
            boolean withdraw_week_limit_button = this.sysparaService.find("withdraw_week_limit_button").getBoolean();
            if (withdraw_week_limit_button) {
                this.checkWithdrawLimit(party, party_kyc, coin_amount_double);
            }
            // 可提现差额开启，取party Withdraw_limit_amount 的可提现金 和剩余金额与流水中的最小值相加
            // 流水为Userdate里的交割，合约，理财，矿池的交易量
            String withdraw_limit_open = this.sysparaService.find("withdraw_limit_open").getSvalue();
            if ("true".equals(withdraw_limit_open)) {
                // 提现限制流水开启后，提现判断用的用户当前流水是使用UserData表的当日流水1还是使用Party表里的用户当前流水2
                String withdraw_limit_open_use_type = this.sysparaService.find("withdraw_limit_open_use_type").getSvalue();
                // 当使用userdata流水提现时，提现限制流水是否加入永续合约流水1增加，2不增加
                String withdraw_limit_contract_or = this.sysparaService.find("withdraw_limit_contract_or").getSvalue();
                if ("1".equals(withdraw_limit_open_use_type)) {
                    // 还差多少可提现金额
                    double fact_withdraw_amount = 0;
                    // 用户Party表里可提现金额参数 -----可为负数
                    double party_withdraw = party.getWithdrawLimitAmount().doubleValue();
                    // userdata交易流水
                    double userdata_turnover = 0;
                    Map<String, UserData> data_all = this.userDataService.cacheByPartyId(partyId);
                    if (data_all != null) {
                        SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMdd");
                        Date date_now = new Date();
                        for (Map.Entry<String, UserData> valueEntry : data_all.entrySet()) {
                            UserData userdata = valueEntry.getValue();
                            // 如果日期等于当天就赋值
                            if (fmt.format(date_now).equals(fmt.format(userdata.getCreateTime()))) {
                                // 永续合约下单金额amount 理财买入金额finance_amount 币币exchange_amount 矿机下单金额miner_amount 交割合约下单金额furtures_amount
                                // 当使用userdata流水提现时，提现限制流水是否加入永续合约流水1增加，2不增加
                                double contract_amount = userdata.getAmount();
                                if ("2".equals(withdraw_limit_contract_or)) {
                                    contract_amount = 0;
                                }
                                double amount_finance_amount = Arith.add(contract_amount, userdata.getFinanceAmount());
                                double exchange_amount_miner_amount = Arith.add(0, userdata.getMinerAmount());
                                // 币币交易流水不加入
                                userdata_turnover = Arith.add(userdata.getFurturesAmount(), Arith.add(amount_finance_amount, exchange_amount_miner_amount));
                            }
                        }
                    }
                    double withdraw_limit_turnover_percent = Double.valueOf(this.sysparaService.find("withdraw_limit_turnover_percent").getSvalue());
                    party_withdraw = Arith.mul(party_withdraw, withdraw_limit_turnover_percent);
                    // 流水小于限额
                    if (userdata_turnover < party_withdraw) {
                        fact_withdraw_amount = Arith.sub(party_withdraw, userdata_turnover);
                        throw new YamiShopBindException("流水小于限额");
                    }
                }
                if ("2".equals(withdraw_limit_open_use_type)) {
                    // 还差多少可提现金额
                    double fact_withdraw_amount = 0;
                    // 用户Party表里可提现金额参数 -----可为负数
                    double party_withdraw = party.getWithdrawLimitAmount().doubleValue();
                    // userdata交易流水
                    double userdata_turnover = party.getWithdrawLimitNowAmount().doubleValue();
                    double withdraw_limit_turnover_percent = Double.valueOf(this.sysparaService.find("withdraw_limit_turnover_percent").getSvalue());
                    party_withdraw = Arith.mul(party_withdraw, withdraw_limit_turnover_percent);
                    // 流水小于限额
                    if (userdata_turnover < party_withdraw) {
                        fact_withdraw_amount = Arith.sub(party_withdraw, userdata_turnover);
                        throw new YamiShopBindException(fact_withdraw_amount + "");
                    }
                }
            }
        } else {
            // 充值
        }
        // 每日银行卡订单取消最大次数
        int orderCancelDayTimes = 0;
        Map<String, Integer> map = (Map<String, Integer>) redisTemplate.opsForValue().get(RedisKeys.C2C_ORDER_CANCEL_DAY_TIMES);
        if (null != map && null != map.get(partyId)) {
            orderCancelDayTimes = map.get(partyId);
        }
        Object obj1 = this.sysparaService.find("bank_card_order_cancel_day_times");
        if (null != obj1) {
            if (orderCancelDayTimes >= Integer.valueOf(this.sysparaService.find("bank_card_order_cancel_day_times").getSvalue()).intValue()) {
                throw new YamiShopBindException("今日取消订单次数太多了，请明日再试");
            }
        }
        DecimalFormat df = new DecimalFormat("#.########");
        ExchangeRate ex = this.exchangeRateService.findBy(Constants.OUT_OR_IN_DEFAULT, currency.toUpperCase());
        if (null == ex) {
            throw new YamiShopBindException("支付币种不正确");
        }
        C2cOrder c2cOrder = new C2cOrder();
        c2cOrder.setPartyId(party.getUserId());
        c2cOrder.setPaymentMethodId(payment_method_id);
        c2cOrder.setOrderNo(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
        // 0未付款
        c2cOrder.setState("0");
        c2cOrder.setNationality(nationality);
        c2cOrder.setImg(img);
        c2cOrder.setDirection(direction);
        c2cOrder.setCurrency(currency);
        c2cOrder.setSymbol("usdt");
        c2cOrder.setSymbolValue(ex.getRata().doubleValue());
        c2cOrder.setCoinAmountFee(Double.valueOf(df.format(fee)).doubleValue());
        c2cOrder.setCoinAmount(Double.valueOf(df.format(Arith.sub(coin_amount_double, c2cOrder.getCoinAmountFee()))).doubleValue());
        c2cOrder.setAmount(Double.valueOf(df.format(Arith.mul(ex.getRata().doubleValue(), coin_amount_double))).doubleValue());
        c2cOrder.setCreateTime(new Date());
        c2cOrder.setHandleTime(null);
        c2cOrder.setCancelTime(null);
        this.c2cOrderService.saveOpen(c2cOrder, party);
        Map<String, Object> data = new HashMap<String, Object>();
        data.put("order_no", c2cOrder.getOrderNo());
        return Result.succeed(data);
    }

    @ApiOperation("取消订单")
    @PostMapping("orderCancel")
    public Result orderCancel(String order_no, String remark) {
        User party = userService.getById(SecurityUtils.getUser().getUserId());
        if (Constants.SECURITY_ROLE_TEST.equals(party.getRoleName())) {
            throw new YamiShopBindException("无权限");
        }
        if (!party.isEnabled()) {
            throw new YamiShopBindException("用户已锁定");
        }
        C2cOrder order = this.c2cOrderService.get(order_no);
        if (null == order || !order.getPartyId().equals(SecurityUtils.getUser().getUserId())) {
            throw new YamiShopBindException("订单不存在");
        }
        order.setRemark(remark);
        // 用户不能取消提现
        if (SecurityUtils.getUser().getUserId().equals(order.getPartyId())) {
            if ("withdraw".equals(order.getDirection())) {
                throw new YamiShopBindException("用户不能取消提现");
            }
            this.c2cOrderService.saveOrderCancel(order, "user");
        }
        return Result.succeed(null);
    }

    /**
     * 获取 银行卡订单 详情
     */
    @GetMapping("get")
    @ApiOperation("获取 银行卡订单 详情")
    public Result get(@RequestParam String order_no, @RequestParam String language) {
        C2cOrder c2cOrder = this.c2cOrderService.get(order_no);
        if (null == c2cOrder) {
            throw new YamiShopBindException("订单不存在");
        }
        List<String> nos = new ArrayList<String>();
        nos.add(c2cOrder.getOrderNo());
        // TODO: 2023/4/15
//        Map<String, Integer> unreadMsgs =this.otcOnlineChatMessageService.unreadMsgsApi(nos);
//        Integer unreadMsg = unreadMsgs.get(c2cOrder.getOrderNo());
//        if (null == unreadMsg) {
//            c2cOrder.setUnreadMsg(0);
//        } else {
//            c2cOrder.setUnreadMsg(unreadMsg.intValue());
//        }
        if (StringUtils.isNotEmpty(c2cOrder.getMethodImg())) {
            String path = Constants.WEB_URL + "/public/showimg!showImg.action?imagePath=" + c2cOrder.getMethodImg();
            c2cOrder.setMethodImg(path);
        }
        // 多语言
        c2cOrder = this.c2cTranslateService.translateOrder(c2cOrder, language);
        long nowTimestamp = (new Date()).getTime();
        long createTimestamp = c2cOrder.getCreateTime().getTime();
        long autoCancelSeconds = 0;
        if ("0".equals(c2cOrder.getState())) {
            autoCancelSeconds = c2cOrder.getExpireTime() * 60 * 1000 - (nowTimestamp - createTimestamp);
        }
        c2cOrder.setAutoCancelTimeRemain((int) (autoCancelSeconds <= 0 ? 0 : autoCancelSeconds / 1000));
        return Result.succeed(c2cOrder);
    }

    /**
     *
     */
    @ApiOperation("获取 支付币种（法币） 列表")
    @RequestMapping("currency")
    public Result currency() {
        Map<String, String> pmtMap = c2cPaymentMethodService.getC2cSyspara("bank_card_currency");
        List<Map<String, Object>> data = new ArrayList<Map<String, Object>>();
        List<ExchangeRate> exchangeRateList = this.exchangeRateService.findBy(Constants.OUT_OR_IN_DEFAULT);
        if (!CollectionUtils.isEmpty(exchangeRateList)) {
            for (ExchangeRate er : exchangeRateList) {
                if (pmtMap.keySet().contains(er.getCurrency())) {
                    Map<String, Object> erMap = new HashMap<String, Object>();
                    erMap.put("out_or_in", er.getOutOrIn());
                    erMap.put("rate", er.getRata());
                    erMap.put("currency", er.getCurrency());
                    erMap.put("name", er.getName());
                    erMap.put("currency_symbol", er.getCurrencySymbol());
                    data.add(erMap);
                }
            }
        }
        return Result.succeed(data);
    }

    /**
     * 获取 银行卡订单 列表
     */
    @GetMapping("list")
    @ApiOperation("获取 银行卡订单 列表")
    public Result list(String page_no, String direction, String state) {
        String partyId = SecurityUtils.getUser().getUserId();
        if (null == partyId) {
            throw new YamiShopBindException("请重新登录");
        }
        if (StringUtils.isNullOrEmpty(page_no)) {
            page_no = "1";
        }
        if (!StringUtils.isInteger(page_no)) {
            throw new YamiShopBindException("页码不是整数");
        }
        if (Integer.valueOf(page_no).intValue() <= 0) {
            throw new YamiShopBindException("页码不能小于等于0");
        }
        int page_no_int = Integer.valueOf(page_no).intValue();
        if (StringUtils.isNotEmpty(direction) && !Arrays.asList("recharge", "withdraw").contains(direction)) {
            throw new YamiShopBindException("充值或提现不正确");
        }
        if (StringUtils.isNotEmpty(state) && !Arrays.asList("0", "3", "4").contains(state)) {
            throw new YamiShopBindException("订单状态不正确");
        }
        Page page = this.c2cOrderService.pagedQuery(page_no_int, 20, direction, state, partyId);
        if (null == page) {
            return Result.succeed(new ArrayList<Map<String, Object>>());
        } else {
            List<String> nos = new ArrayList<String>();
            for (Map<String, Object> map : (List<Map<String, Object>>) page.getRecords()) {
                nos.add(map.get("order_no").toString());
            }
            Map<String, Integer> unreadMsgs = this.otcOnlineChatMessageService.unreadMsgsApi(nos);
            for (Map<String, Object> map : (List<Map<String, Object>>) page.getRecords()) {
                String orderNo = map.get("order_no").toString();
                if (unreadMsgs.containsKey(orderNo)) {
                    map.put("unread_msg", unreadMsgs.get(orderNo));
                }
            }
            return Result.succeed(page.getRecords());
        }
    }
}