package com.yami.trading.service.exchange.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.gson.Gson;
import com.yami.trading.bean.data.domain.Realtime;
import com.yami.trading.bean.exchange.ExchangeApplyOrder;
import com.yami.trading.bean.exchange.dto.ExchangeApplyOrderDto;
import com.yami.trading.bean.exchange.dto.ExchangeSymbolDto;
import com.yami.trading.bean.exchange.dto.SumEtfDto;
import com.yami.trading.bean.item.domain.Item;
import com.yami.trading.bean.model.CapitaltWallet;
import com.yami.trading.bean.model.MoneyLog;
import com.yami.trading.bean.model.Wallet;
import com.yami.trading.bean.model.WalletExtend;
import com.yami.trading.bean.purchasing.dto.ExchangeRecord;
import com.yami.trading.common.constants.Constants;
import com.yami.trading.common.exception.YamiShopBindException;
import com.yami.trading.common.util.*;
import com.yami.trading.dao.exchange.ExchangeApplyOrderMapper;
import com.yami.trading.service.CapitaltWalletService;
import com.yami.trading.service.MoneyLogService;
import com.yami.trading.service.WalletService;
import com.yami.trading.service.data.DataService;
import com.yami.trading.service.exchange.ExchangeApplyOrderService;
import com.yami.trading.service.item.ItemService;
import com.yami.trading.service.syspara.SysparaService;
import com.yami.trading.service.user.UserDataService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.xml.crypto.Data;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;

import static com.yami.trading.bean.item.domain.ItemConstants.*;

@Service
@Slf4j
public class ExchangeApplyOrderServiceImpl extends ServiceImpl<ExchangeApplyOrderMapper, ExchangeApplyOrder> implements ExchangeApplyOrderService {
    @Autowired
    SysparaService sysparaService;
    @Autowired
    ItemService itemService;
    @Autowired
    DataService dataService;
    @Autowired
    WalletService walletService;
    @Autowired
    MoneyLogService moneyLogService;
    @Autowired
    UserDataService userDataService;
    @Autowired
    CapitaltWalletService capitaltWalletService;

    @Override
    public List<ExchangeApplyOrder> findSubmitted() {

        return list(Wrappers.<ExchangeApplyOrder>query().lambda().eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_SUBMITTED));
    }

    @Override
    @Transactional
    public void saveOpen(ExchangeApplyOrder order, Realtime realtime) {

        double sub = Arith.sub(order.getVolume(), order.getFee());// 买入数量-手续费=到账
        double amount = Arith.div(sub, realtime.getClose().doubleValue(), 8);// 可以买的数量
        // order.setCreate_time(new Date());
        order.setCloseTime(new Date());
        order.setClosePrice(realtime.getClose().doubleValue());
        WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
        double amount_before = walletExtend.getAmount();

        this.walletService.updateExtend(walletExtend.getPartyId().toString(), walletExtend.getWallettype(), amount);

        /*
         * 保存资金日志
         */
        MoneyLog moneylog_deposit = new MoneyLog();
        moneylog_deposit.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
        moneylog_deposit.setAmountBefore(new BigDecimal(amount_before));
        moneylog_deposit.setAmount(new BigDecimal(amount));
        moneylog_deposit.setAmountAfter(new BigDecimal(walletExtend.getAmount()));
        moneylog_deposit.setLog("委托单，订单号[" + order.getOrderNo() + "]");
        moneylog_deposit.setUserId(order.getPartyId());
        moneylog_deposit.setSymbol(order.getSymbol());
        moneylog_deposit.setWalletType(order.getSymbol());
        moneylog_deposit.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_OPEN);
        moneyLogService.save(moneylog_deposit);
        order.setState(ExchangeApplyOrder.STATE_CREATED);
        order.setAmount(order.getVolume());
        order.setWalletFee(order.getFee());
        updateById(order);
    }

    @Override
    @Transactional
    public void saveClose(ExchangeApplyOrder order, Realtime realtime) {

        double sub = Arith.sub(order.getVolume(), order.getFee());
        double amount = Arith.mul(sub, realtime.getClose().doubleValue());
        order.setCloseTime(new Date());
        order.setClosePrice(realtime.getClose().doubleValue());
        Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
//        CapitaltWallet capitaltWallet = capitaltWalletService.getUserIdWallet(order.getPartyId());
        double amount_before = wallet.getMoney().doubleValue();
        this.walletService.update(wallet.getUserId().toString(), amount);
//        this.capitaltWalletService.update(capitaltWallet, amount);

        /*
         * 保存资金日志
         */
        MoneyLog moneylog_deposit = new MoneyLog();
        moneylog_deposit.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
        moneylog_deposit.setAmountBefore(new BigDecimal(amount_before));
        moneylog_deposit.setAmount(new BigDecimal(amount));
        moneylog_deposit.setAmountAfter(wallet.getMoney());
        moneylog_deposit.setLog("委托单，订单号[" + order.getOrderNo() + "]");
        moneylog_deposit.setUserId(order.getPartyId());
        moneylog_deposit.setWalletType(Constants.WALLET);
        moneylog_deposit.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CLOSE);
        moneylog_deposit.setSymbol(order.getSymbol());
        moneyLogService.save(moneylog_deposit);
        order.setAmount(amount);
        order.setWalletFee(Arith.mul(order.getFee(), realtime.getClose().doubleValue()));
        order.setState(ExchangeApplyOrder.STATE_CREATED);
        updateById(order);
    }

    @Override
    public void saveCreate(ExchangeApplyOrder order) {

        boolean order_open = sysparaService.find("exchange_order_open").getBoolean();
        if (!order_open) {
            throw new YamiShopBindException("不在交易时段");
        }
        Item item = itemService.findBySymbol(order.getSymbol());
        if (item == null) {
            throw new YamiShopBindException("参数错误");
        }
        List<Realtime> realtimes = dataService.realtime(order.getSymbol());
        double close = 1;
        if (realtimes != null && realtimes.size() > 0) {
            close = realtimes.get(0).getClose().doubleValue();
        }
        order.setClosePrice(close);
        if (ExchangeApplyOrder.OFFSET_OPEN.equals(order.getOffset())) {
            open(order);
        } else if (ExchangeApplyOrder.OFFSET_CLOSE.equals(order.getOffset())) {
            close(order);
        }
    }

    @Override
    public ExchangeApplyOrder findByOrderNo(String orderNo) {

        return getOne(Wrappers.<ExchangeApplyOrder>query().lambda().eq(ExchangeApplyOrder::getOrderNo, orderNo));
    }

    @Override
    public List<ExchangeSymbolDto> getETFListByUserId(String userId, String type) {

        List<String> symbols = itemService.findByType(type).stream().map(Item::getSymbol).collect(Collectors.toList());
        symbols.add("-1");
        log.info(JSONUtil.toJsonStr(symbols));
        LambdaQueryWrapper<ExchangeApplyOrder> lambdaQueryWrapper = Wrappers.<ExchangeApplyOrder>query().lambda();
        lambdaQueryWrapper.eq(ExchangeApplyOrder::getPartyId, userId);
        lambdaQueryWrapper.in(ExchangeApplyOrder::getSymbol, symbols);
        lambdaQueryWrapper.notIn(ExchangeApplyOrder::getOffset, ExchangeApplyOrder.OFFSET_CLOSE);
//        lambdaQueryWrapper.notIn(ExchangeApplyOrder::getOrderPriceType, "opponent");
        lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CREATED);
        lambdaQueryWrapper.orderByDesc(ExchangeApplyOrder::getCreateTime);
        List<ExchangeApplyOrder> list = list(lambdaQueryWrapper);
        return getDataList(list);
    }

    private static List<ExchangeApplyOrder> getData() {

        List<ExchangeApplyOrder> exchangeApplyOrders = new ArrayList<>();
        ExchangeApplyOrder exchangeApplyOrder = new ExchangeApplyOrder();
        exchangeApplyOrder.setSymbol("usdt");
        exchangeApplyOrder.setVolume(1000.0);
        exchangeApplyOrder.setClosePrice(100.0);
        exchangeApplyOrders.add(exchangeApplyOrder);
//
//        ExchangeApplyOrder exchangeApplyOrder2=new ExchangeApplyOrder();
//        exchangeApplyOrder2.setSymbol("usdt");
//        exchangeApplyOrder2.setVolume(1000.0);
//        exchangeApplyOrder2.setClosePrice(50.0);
//        exchangeApplyOrders.add(exchangeApplyOrder2);
        return exchangeApplyOrders;
    }

    public List<ExchangeSymbolDto> getDataList(List<ExchangeApplyOrder> dbList) {

        List<ExchangeSymbolDto> result = new ArrayList<>();
        Map<String, List<ExchangeSymbolDto>> map = new HashMap<>();
        for (ExchangeApplyOrder order : dbList) {
            List<ExchangeSymbolDto> exchangeSymbolDtos = map.get(order.getSymbol());
            if (exchangeSymbolDtos == null) {
                exchangeSymbolDtos = new ArrayList<>();
            }
//            Realtime realtime = new Realtime();
//            realtime.setClose(new BigDecimal(99));
//            realtime.setOpen(new BigDecimal(100));
//            ExchangeSymbolDto exchangeSymbolDto = new ExchangeSymbolDto();
//            exchangeSymbolDto.setVolume(order.getVolume());
//            exchangeSymbolDto.setName("test");
//            exchangeSymbolDto.setOpenPrice(realtime.getOpen().doubleValue());
//            exchangeSymbolDto.setCurrentPrice(realtime.getClose().doubleValue());
//            exchangeSymbolDto.setPrice(order.getClosePrice());
//            exchangeSymbolDtos.add(exchangeSymbolDto);
//            map.put(order.getSymbol(), exchangeSymbolDtos);
            List<Realtime> symbolList = dataService.realtime(order.getSymbol());
            if (!CollectionUtil.isEmpty(symbolList)) {
                Realtime realtime = symbolList.get(0);
                ExchangeSymbolDto exchangeSymbolDto = new ExchangeSymbolDto();
                exchangeSymbolDto.setVolume(order.getVolume());
                exchangeSymbolDto.setName(realtime.getName());
                exchangeSymbolDto.setOpenPrice(realtime.getOpen().doubleValue());
                exchangeSymbolDto.setCurrentPrice(realtime.getClose().doubleValue());
                exchangeSymbolDto.setPrice(order.getClosePrice());
                exchangeSymbolDtos.add(exchangeSymbolDto);
                map.put(order.getSymbol(), exchangeSymbolDtos);
            }
        }
        for (String key : map.keySet()) {
            List<ExchangeSymbolDto> list = map.get(key);
            double volume = 0; //可用
            double cost = 0.0;
            double marketValue = 0; //市值
            double currentPrice = 0; //当前价格
            double profitLoss = 0; //总盈亏
            double toDayProfitLoss = 0; //今日总盈亏
            double openPrice = 0;
            String name = "";
            for (ExchangeSymbolDto dto : list) {
                volume += dto.getVolume();
                name = dto.getName();
                cost += (dto.getVolume() * dto.getPrice());
                currentPrice = dto.getCurrentPrice();
                openPrice = dto.getOpenPrice();
                marketValue += (dto.getCurrentPrice() * dto.getVolume());
            }
            double price = 0;
            if (volume == 0) {
                price = 0;
            } else {
                price = cost / volume;
            }
            toDayProfitLoss = (marketValue - (openPrice * volume));
            profitLoss = marketValue - cost;
            ExchangeSymbolDto exchangeSymbolDto = new ExchangeSymbolDto();
            exchangeSymbolDto.setVolume(new BigDecimal(volume).setScale(2, RoundingMode.HALF_UP).doubleValue());
            exchangeSymbolDto.setPositionVolume(new BigDecimal(volume).setScale(2, RoundingMode.HALF_UP).doubleValue());
            exchangeSymbolDto.setPrice(new BigDecimal(price).setScale(2, RoundingMode.HALF_UP).doubleValue());
            exchangeSymbolDto.setName(name);
            exchangeSymbolDto.setSymbol(key);
            exchangeSymbolDto.setToDayProfitLoss(new BigDecimal(toDayProfitLoss).setScale(2, RoundingMode.HALF_UP).doubleValue());
            exchangeSymbolDto.setToDayProfitLossPercentage(calculateProfitPercentage(openPrice, currentPrice));
            exchangeSymbolDto.setCurrentPrice(new BigDecimal(currentPrice).setScale(2, RoundingMode.HALF_UP).doubleValue());
            exchangeSymbolDto.setOpenPrice(new BigDecimal(openPrice).setScale(2, RoundingMode.HALF_UP).doubleValue());
            exchangeSymbolDto.setMarketValue(new BigDecimal(marketValue).setScale(2, RoundingMode.HALF_UP).doubleValue());
            exchangeSymbolDto.setProfitLoss(new BigDecimal(profitLoss).setScale(2, RoundingMode.HALF_UP).doubleValue());
            exchangeSymbolDto.setProfitLossPercentage(calculateProfitPercentage(price, currentPrice));
            result.add(exchangeSymbolDto);
        }
        return result;
    }

    public static double calculateProfitPercentage(double buyPrice, double currentPrice) {

        double profit = currentPrice - buyPrice;
        double profitPercentage = (profit / buyPrice) * 100;
        System.out.println(profitPercentage);
        return new BigDecimal(profitPercentage).setScale(2, RoundingMode.HALF_UP).doubleValue();
    }

    public static void test() {


        // System.out.printf(new Gson().toJson(getDataList(getData())));
    }

    public static void main(String[] args) {

        test();
    }

    @Override
    public SumEtfDto getProfitLossByUserId(String userId, String type) {

        List<ExchangeSymbolDto> list = getETFListByUserId(userId, type);

        double profitLoss = 0;  //盈亏
        double toDayProfitLoss = 0; //今日盈亏
        double sumPrice = 0;  //总资产
        double sumVolume = 0; //可用
        for (ExchangeSymbolDto order : list) {
            profitLoss += order.getProfitLoss();
            toDayProfitLoss += order.getToDayProfitLoss();
            sumPrice += order.getMarketValue();
            sumVolume += order.getVolume();

        }
        SumEtfDto sumEtfDto = new SumEtfDto();
        sumEtfDto.setProfitLoss(new BigDecimal(profitLoss).setScale(2, RoundingMode.HALF_UP).doubleValue());
        sumEtfDto.setSumPrice(new BigDecimal(sumPrice).setScale(2, RoundingMode.HALF_UP).doubleValue());
        sumEtfDto.setToDayProfitLoss(new BigDecimal(toDayProfitLoss).setScale(2, RoundingMode.HALF_UP).doubleValue());
        // usdt余额
        Wallet wallet = new Wallet();
        if (!"".equals(userId) && userId != null) {
            wallet = walletService.findByUserId(userId.toString());
        }
        sumEtfDto.setSumVolume(wallet.getMoney().setScale(2, RoundingMode.HALF_UP).doubleValue());
        return sumEtfDto;
    }

    @Override
    public void saveCancel(String partyId, String order_no) {

        ExchangeApplyOrder order = findByOrderNo(order_no);
        if (order == null || !"submitted".equals(order.getState()) || !partyId.equals(order.getPartyId().toString())) {
            return;
        }
        // 如果是计划委托则不返回余额
        if (order.isTriggerOrder()) {
            if (ExchangeApplyOrder.OFFSET_OPEN.equals(order.getOffset())) {
                Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
                double amount_before = wallet.getMoney().doubleValue();
                MoneyLog moneylog = new MoneyLog();
                moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
                moneylog.setAmountBefore(new BigDecimal(amount_before));
                moneylog.setAmount(new BigDecimal(0));
                moneylog.setAmountAfter(new BigDecimal(amount_before));
                moneylog.setLog("币币交易计划委托单撤单，订单号[" + order.getOrderNo() + "]");
                moneylog.setUserId(order.getPartyId());
                moneylog.setWalletType(Constants.WALLET);
                moneylog.setSymbol(order.getSymbol());
                moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CANCEL);
                moneyLogService.save(moneylog);
            } else if (ExchangeApplyOrder.OFFSET_CLOSE.equals(order.getOffset())) {
                WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
                double amount_before = walletExtend.getAmount();

                /*
                 * 保存资金日志
                 */
                MoneyLog moneylog = new MoneyLog();
                moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
                moneylog.setAmountBefore(new BigDecimal(amount_before));
                moneylog.setAmount(new BigDecimal(0));
                moneylog.setAmountAfter(new BigDecimal(amount_before));
                moneylog.setLog("币币交易计划委托单撤单，订单号[" + order.getOrderNo() + "]");
                moneylog.setUserId(order.getPartyId());
                moneylog.setWalletType(order.getSymbol());
                moneylog.setSymbol(order.getSymbol());
                moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CANCEL);
                moneyLogService.save(moneylog);
            }
            order.setState(ExchangeApplyOrder.STATE_CANCELED);
        }
        if (!order.isTriggerOrder()) {
            if (ExchangeApplyOrder.OFFSET_OPEN.equals(order.getOffset())) {
                Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
//                CapitaltWallet wallet = capitaltWalletService.getUserIdWallet(order.getPartyId());
                double amount_before = wallet.getMoney().doubleValue();
                wallet.setMoney(new BigDecimal(Arith.add(wallet.getMoney().doubleValue(), order.getVolume())));
//                capitaltWalletService.updateById(wallet);
//				wallet.setMoney(wallet.getMoney().add(BigDecimal.valueOf(order.getVolume())));
//                Arith.add(wallet.getMoney(), order.getVolume())
//				walletService.update(wallet);
//                walletService.update(wallet.getUserId().toString(), order.getVolume());
                MoneyLog moneylog = new MoneyLog();
                moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
                moneylog.setAmountBefore(new BigDecimal(amount_before));
                moneylog.setAmount(new BigDecimal(order.getVolume()));
                moneylog.setAmount_after(wallet.getMoney());
                moneylog.setLog("币币交易撤单，订单号[" + order.getOrderNo() + "]");
                moneylog.setUserId(order.getPartyId());
                moneylog.setWalletType(Constants.WALLET);
                moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CANCEL);
                moneylog.setSymbol(order.getSymbol());
                moneyLogService.save(moneylog);
            } else if (ExchangeApplyOrder.OFFSET_CLOSE.equals(order.getOffset())) {
                WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
                double amount_before = walletExtend.getAmount();
//				walletExtend.setAmount(Arith.add(walletExtend.getAmount(), order.getVolume()));
//				walletService.update(walletExtend);
                walletService.updateExtend(walletExtend.getPartyId().toString(), walletExtend.getWallettype(),
                        order.getVolume());
                /*
                 * 保存资金日志
                 */
                MoneyLog moneylog = new MoneyLog();
                moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
                moneylog.setAmountBefore(new BigDecimal(amount_before));
                moneylog.setAmount(new BigDecimal(order.getVolume()));
                moneylog.setAmountAfter(new BigDecimal(Arith.add(walletExtend.getAmount(), order.getVolume())));
                moneylog.setLog("币币交易撤单，订单号[" + order.getOrderNo() + "]");
                moneylog.setUserId(order.getPartyId());
                moneylog.setWalletType(order.getSymbol());
                moneylog.setSymbol(order.getSymbol());
                moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CANCEL);
                moneyLogService.save(moneylog);
            }
            order.setState(ExchangeApplyOrder.STATE_CANCELED);
        }
        updateById(order);
    }

    @Override
    public Page<ExchangeApplyOrderDto> listPage(Page page, String rolename, String userName, String orderNo, String state, String offset, String symbolType, String userCode,String symbol) {

        return baseMapper.listPage(page, rolename, userName, orderNo, state, offset, symbolType,  userCode , symbol);
    }

    @Override
    public ExchangeApplyOrder findByOrderNoAndPartyId(String order_no, String userId) {

        return getOne(Wrappers.<ExchangeApplyOrder>query().lambda().eq(ExchangeApplyOrder::getOrderNo, order_no).eq(ExchangeApplyOrder::getPartyId, userId));
    }

    @Override
    public List<Map<String, Object>> getPaged(int pageNo, int size, String userId, String symbol, String type, String isAll, String startTime, String endTime, String symbolType,
                                              String orderPriceType) {

        LambdaQueryWrapper<ExchangeApplyOrder> lambdaQueryWrapper = Wrappers.<ExchangeApplyOrder>query().lambda();
        lambdaQueryWrapper.eq(ExchangeApplyOrder::getPartyId, userId);
        if (!StringUtils.isNullOrEmpty(symbol)) {
            lambdaQueryWrapper.eq(ExchangeApplyOrder::getSymbol, symbol);
        }
        if (StringUtils.isNotEmpty(orderPriceType)) {
            lambdaQueryWrapper.eq(ExchangeApplyOrder::getOrderPriceType, orderPriceType);
        }
        if (null != isAll) {
            List<String> items = itemService.getAllSymbol();
            lambdaQueryWrapper.in(ExchangeApplyOrder::getSymbol, items);
        }
        if ("orders".equals(type)) {
//            lambdaQueryWrapper.notIn(ExchangeApplyOrder::getOrderPriceType, "opponent");
            lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_SUBMITTED);
        } else if ("hisorders".equals(type)) {
//            lambdaQueryWrapper.notIn(ExchangeApplyOrder::getOrderPriceType, "opponent");
            lambdaQueryWrapper.in(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CREATED, ExchangeApplyOrder.STATE_CANCELED);
        } else if ("opponent".equals(type)) {
//            lambdaQueryWrapper.notIn(ExchangeApplyOrder::getOrderPriceType, "opponent");
            lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CREATED);
        } else if ("canceled".equals(type)) {
//            lambdaQueryWrapper.notIn(ExchangeApplyOrder::getOrderPriceType, "opponent");
            lambdaQueryWrapper.eq(ExchangeApplyOrder::getState, ExchangeApplyOrder.STATE_CANCELED);
        }
        if (!StringUtils.isNullOrEmpty(startTime)) {
            lambdaQueryWrapper.ge(ExchangeApplyOrder::getCreateTime, DateUtil.minDate(DateUtil.stringToDate(startTime, "yyyy-MM-dd")));
//			parameters.put("startTime",DateUtils.toDate(startTime));
        }
        if (!StringUtils.isNullOrEmpty(endTime)) {
            lambdaQueryWrapper.le(ExchangeApplyOrder::getCreateTime, DateUtil.maxDate(DateUtil.stringToDate(endTime, "yyyy-MM-dd")));
        }
        List<String> symbols = itemService.findByType(symbolType).stream().map(Item::getSymbol).collect(Collectors.toList());
        symbols.add("-1");
        if (StringUtils.isNotEmpty(symbolType)) {
            lambdaQueryWrapper.in(ExchangeApplyOrder::getSymbol, symbols);
        }
        lambdaQueryWrapper.orderByDesc(ExchangeApplyOrder::getCreateTime);
        Page page = new Page(pageNo, size);
        page(page, lambdaQueryWrapper);
        List<Map<String, Object>> data;
        if (!StringUtils.isNullOrEmpty(symbol) || null != isAll) {
//        if (StringUtils.isNullOrEmpty(type)) {
            // 币币交易的记录
            data = this.entrustBulidData(page.getRecords());
        } else {
            // 兑换记录
            data = this.bulidData(page.getRecords());
        }
        return data;
    }

    private List<Map<String, Object>> bulidData(List<ExchangeApplyOrder> list) {

        Map<String, ExchangeRecord> recordMap = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            ExchangeApplyOrder order = list.get(i);
            ExchangeRecord record = new ExchangeRecord();
            if (recordMap.containsKey(order.getOrderNo())) {
                record = recordMap.get(order.getOrderNo());
            }
            record.setClosePrice(order.getClosePrice());
            record.setState(order.getState());
            record.setCreate_time(DateUtils.format(order.getCreateTime(), DateUtils.DF_yyyyMMddHHmmss));
            // 开仓 买入**币
            if (ExchangeApplyOrder.OFFSET_CLOSE.equals(order.getOffset())) {
                if (recordMap.containsKey(order.getOrderNo())) {
                    record.setSymbol(order.getSymbol());
                    record.setAmount(order.getVolume());
                } else {
                    record.setSymbol(order.getSymbol());
                    record.setAmount(order.getVolume());
                    // 针对 **币 --兑换-- usdt
                    record.setAmount_to(order.getSymbolValue());
                }
            }
            // 平仓 卖出**币
            else if (ExchangeApplyOrder.OFFSET_OPEN.equals(order.getOffset())) {
                // new BigDecimal(String.valueOf(value)).toPlainString()
                if (recordMap.containsKey(order.getOrderNo())) {
                    record.setSymbol_to(order.getSymbol());
                    record.setAmount_to(order.getSymbolValue());
                } else {
                    record.setSymbol_to(order.getSymbol());
                    record.setAmount(order.getVolume());
                    record.setAmount_to(order.getSymbolValue());
                }
            }
            recordMap.put(order.getOrderNo(), record);
        }
        for (ExchangeRecord entry : recordMap.values()) {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("symbol", entry.getSymbol());
            Item bySymbol = itemService.findBySymbol(entry.getSymbol());
            if (bySymbol != null) {
                map.put("symbol_data", bySymbol.getSymbolData());
            }
            map.put("symbol_to", entry.getSymbol_to());
            map.put("amount", entry.getAmount());
            map.put("amount_to", entry.getAmount_to());
            map.put("create_time", entry.getCreate_time());
            map.put("state", entry.getState());
            map.put("closePrice", entry.getClosePrice());


            data.add(map);
        }
        if (data.size() > 0) {
            Collections.sort(data, new Comparator<Map<String, Object>>() {
                @Override
                public int compare(Map<String, Object> o1, Map<String, Object> o2) {

                    String time1 = String.valueOf(o1.get("create_time"));
                    String time2 = String.valueOf(o2.get("create_time"));
                    return time2.compareTo(time1);
                }
            });
            return data;
        }
        return data;
    }

    private List<Map<String, Object>> entrustBulidData(List<ExchangeApplyOrder> list) {

        List<Map<String, Object>> data = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            ExchangeApplyOrder order = list.get(i);
            Map<String, Object> map = new HashMap<String, Object>();
            String symbol = itemService.findBySymbol(order.getSymbol()).getName();
            map.put("profitLoss", 0);
            List<Realtime> symbolList = dataService.realtime(symbol);
            if (!CollectionUtil.isEmpty(symbolList)) {
                Realtime realtime = symbolList.get(0);
                double oldPrie = order.getClosePrice().doubleValue() * order.getVolume().doubleValue();
                double newPrie = realtime.getClose().doubleValue() * order.getVolume().doubleValue();
                map.put("profitLoss", oldPrie - newPrie); //盈亏
            }
            map.put("order_no", order.getOrderNo());
            map.put("name", symbol);
            map.put("symbol", order.getSymbol());
            Item bySymbol = itemService.findBySymbol(symbol);
            if (bySymbol != null) {
                map.put("symbol_data", bySymbol.getSymbolData());
            }

            map.put("create_time", DateUtil.formatDate(order.getCreateTime(), DateUtils.DF_yyyyMMddHHmmss));
            map.put("volume", new BigDecimal(order.getVolume()).setScale(6, RoundingMode.HALF_UP));
            // 买的时候total 为volume，卖的时候total = volume*closeTime
            if("open".equalsIgnoreCase(order.getOffset())){
                map.put("total", new BigDecimal(order.getVolume()).setScale(6, RoundingMode.HALF_UP));
            }else{
                map.put("total", new BigDecimal(order.getVolume()*order.getClosePrice()).setScale(2, RoundingMode.HALF_UP));
            }
            map.put("offset", order.getOffset());
            map.put("price", order.getPrice());
            map.put("order_price_type", order.getOrderPriceType());
            map.put("state", order.getState());
            map.put("closePrice", order.getClosePrice());
            map.put("fee", order.getFee());
            map.put("create_time_ts", order.getCreateTimeTs());
            map.put("update_time_ts", order.getUpdateTimeTs());
//			map.put("amount", Arith.mul(order.getVolume(), order.getUnit_amount()));
            map.put("trigger_price", order.getTriggerPrice());
            map.put("is_trigger_order", order.isTriggerOrder());
            data.add(map);
        }
        return data;
    }

    /**
     * 开仓委托
     */
    public void open(ExchangeApplyOrder order) {

        order.setOrderNo(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
        order.setFee(Arith.mul(order.getVolume(), sysparaService.find("exchange_apply_order_buy_fee").getDouble()));
        order.setCreateTime(new Date());
        // 买入数量 - 手续费 = 到账
        double sub = Arith.sub(order.getVolume(), order.getFee());
        // 可以买的数量
        double amount = Arith.div(sub, order.getClosePrice(), 8);
        order.setSymbolValue(amount);
        Wallet wallet = this.walletService.saveWalletByPartyId(order.getPartyId());
//        CapitaltWallet userIdWallet = capitaltWalletService.getUserIdWallet(order.getPartyId());
        double amount_before = wallet.getMoney().doubleValue();
        // 如果是计划委托，则先不扣钱
        if (order.isTriggerOrder()) {

            /*
             * 保存资金日志
             */
            MoneyLog moneylog_deposit = new MoneyLog();
            moneylog_deposit.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
            moneylog_deposit.setAmountBefore(new BigDecimal(amount_before));
            moneylog_deposit.setAmount(new BigDecimal(0));
            moneylog_deposit.setAmountAfter(new BigDecimal(amount_before));
            moneylog_deposit.setLog("币币交易计划委托订单，订单号[" + order.getOrderNo() + "]");
            moneylog_deposit.setUserId(order.getPartyId());
            moneylog_deposit.setWalletType(Constants.WALLET);
            moneylog_deposit.setSymbol(order.getSymbol());
            moneylog_deposit.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_OPEN);
            moneyLogService.save(moneylog_deposit);
            save(order);
        }
        if (!order.isTriggerOrder()) {
            if (wallet.getMoney().doubleValue() < order.getVolume().doubleValue()) {
                throw new YamiShopBindException("余额不足");
            }
            this.walletService.update(wallet.getUserId().toString(), Arith.sub(0, order.getVolume()));
//            capitaltWalletService.update(userIdWallet, Arith.sub(0, order.getVolume()));
            /*
             * 保存资金日志
             */
            MoneyLog moneylog_deposit = new MoneyLog();
            moneylog_deposit.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
            moneylog_deposit.setAmountBefore(new BigDecimal(amount_before));
            moneylog_deposit.setAmount(new BigDecimal(Arith.sub(0, order.getVolume().doubleValue())));
            moneylog_deposit.setAmountAfter(new BigDecimal(Arith.sub(wallet.getMoney().doubleValue(), order.getVolume())));
            moneylog_deposit.setLog("币币交易，订单号[" + order.getOrderNo() + "]");
            moneylog_deposit.setUserId(order.getPartyId());
            moneylog_deposit.setWalletType(Constants.WALLET);
            moneylog_deposit.setSymbol(order.getSymbol());
            moneylog_deposit.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_OPEN);
            moneyLogService.save(moneylog_deposit);
            save(order);
            userDataService.saveBuy(order);
        }
    }

    /**
     * 卖币
     */
    public void close(ExchangeApplyOrder order) {

        order.setOrderNo(DateUtil.getToday("yyMMddHHmmss") + RandomUtil.getRandomNum(8));
        order.setCreateTime(new Date());
        order.setFee(Arith.mul(order.getVolume(), sysparaService.find("exchange_apply_order_sell_fee").getDouble()));
        double sub = Arith.sub(order.getVolume(), order.getFee());
        double amount = Arith.mul(sub, order.getClosePrice());
        order.setSymbolValue(amount);
        // .close
        WalletExtend walletExtend = walletService.saveExtendByPara(order.getPartyId(), order.getSymbol());
        double amount_before = walletExtend.getAmount();
        // 如果是计划委托，则先不扣钱
        if (order.isTriggerOrder()) {
            /*
             * 保存资金日志
             */
            MoneyLog moneylog = new MoneyLog();
            moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
            moneylog.setAmountBefore(new BigDecimal(amount_before));
            moneylog.setAmount(new BigDecimal(0));
            moneylog.setAmountAfter(new BigDecimal(amount_before));
            moneylog.setLog("币币交易计划委托订单，订单号[" + order.getOrderNo() + "]");
            moneylog.setUserId(order.getPartyId());
            moneylog.setWalletType(order.getSymbol());
            moneylog.setSymbol(order.getSymbol());
            moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CLOSE);
            moneyLogService.save(moneylog);
            save(order);
        }
        if (!order.isTriggerOrder()) {
            if (order.getVolume() > walletExtend.getAmount()) {
                throw new YamiShopBindException("仓位不足");
            }
            walletService.updateExtend(walletExtend.getPartyId().toString(), walletExtend.getWallettype(),
                    Arith.sub(0, order.getVolume()));
            /*
             * 保存资金日志
             */
            MoneyLog moneylog = new MoneyLog();
            moneylog.setCategory(Constants.MONEYLOG_CATEGORY_EXCHANGE);
            moneylog.setAmountBefore(new BigDecimal(amount_before));
            moneylog.setAmount(new BigDecimal(Arith.sub(0, order.getVolume())));
            moneylog.setAmountAfter(new BigDecimal(Arith.sub(walletExtend.getAmount(), order.getVolume())));
            moneylog.setLog("币币交易，订单号[" + order.getOrderNo() + "]");
            moneylog.setUserId(order.getPartyId());
            moneylog.setWalletType(order.getSymbol());
            moneylog.setSymbol(order.getSymbol());
            moneylog.setContentType(Constants.MONEYLOG_CONTENT_EXCHANGE_CLOSE);
            moneyLogService.save(moneylog);
            save(order);
            userDataService.saveSell(order);
        }
    }

}