package com.xcong.excoin.modules.dataMonitoring.service.impl;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.validation.Valid;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xcong.excoin.common.entity.QueryRequest;
import com.xcong.excoin.modules.dataMonitoring.entity.DataMonitoringEntity;
import com.xcong.excoin.modules.dataMonitoring.mapper.DataMonitoringMapper;
import com.xcong.excoin.modules.dataMonitoring.service.DataMonitoringService;
import com.xcong.excoin.modules.member.entity.MemberAuthenticationEntity;
import com.xcong.excoin.modules.member.entity.MemberEntity;
import com.xcong.excoin.modules.member.mapper.MemberAuthenticationMapper;
import com.xcong.excoin.modules.member.mapper.MemberMapper;
import com.xcong.excoin.modules.trademanage.entity.ContractHoldOrderEntity;
import com.xcong.excoin.modules.trademanage.entity.ContractOrderEntity;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
@RequiredArgsConstructor
public class DataMonitoringServiceImpl extends ServiceImpl<DataMonitoringMapper, DataMonitoringEntity> implements DataMonitoringService {

	private final DataMonitoringMapper dataMonitoringMapper;
	
	private final MemberMapper memberMapper;
	
	private final MemberAuthenticationMapper memberAuthenticationMapper;

	@Override
	public IPage<DataMonitoringEntity> findDataMonitoringListInPage(DataMonitoringEntity dataMonitoringEntity,
			QueryRequest request) {
		Page<DataMonitoringEntity> page = new Page<>(request.getPageNum(), request.getPageSize());
		IPage<DataMonitoringEntity> DataMonitoringEntitys = dataMonitoringMapper.findDataMonitoringListInPage(page, dataMonitoringEntity);
		List<DataMonitoringEntity> records = DataMonitoringEntitys.getRecords();
		if(CollUtil.isNotEmpty(records)) {
			for(DataMonitoringEntity DataMonitoringEntity :records) {
				Long memberId = DataMonitoringEntity.getMemberId();
				Map<String, Object> columnMap = new HashMap<>();
				columnMap.put("member_id", memberId);
				List<MemberAuthenticationEntity> selectByMap = memberAuthenticationMapper.selectByMap(columnMap );
				if(selectByMap != null && selectByMap.size() > 0) {
					MemberAuthenticationEntity memberAuthenticationEntity = selectByMap.get(0);
					String firstName = memberAuthenticationEntity.getFirstName();
					String secondName = memberAuthenticationEntity.getSecondName();
					String realName = firstName + secondName;
					DataMonitoringEntity.setRealName(realName);
				}
			}
		}
		
		return DataMonitoringEntitys;
	}

	@Override
	@Transactional
	public void dataMonitoringListUpdate(@Valid DataMonitoringEntity dataMonitoringEntity) {
		String orderType = dataMonitoringEntity.getOrderType();
		//1---每日开仓数超过30(包含当前持仓和历史持仓)
		if(StrUtil.isNotEmpty(orderType) && orderType.equals("1")) {
			
			//获取【合约持仓订单表】
			Date date = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
			String format = sdf.format(date);
			List<ContractHoldOrderEntity> contractHoldOrderEntitys = dataMonitoringMapper.selectContractHoldOrderListInToday(format);
			List<ContractOrderEntity> contractOrderEntitys = dataMonitoringMapper.selectContractOrderListInToday(format);
			
			Set<Long> set = new HashSet<>();
			//获取当前持仓的用户
			if(CollUtil.isNotEmpty(contractHoldOrderEntitys)) {
				for(ContractHoldOrderEntity contractHoldOrderEntity : contractHoldOrderEntitys) {
					Long memberId = contractHoldOrderEntity.getMemberId();
					set.add(memberId);
				}
			}
			//获取今日历史订单数据
			if(CollUtil.isNotEmpty(contractOrderEntitys)) {
				for(ContractOrderEntity contractOrderEntity : contractOrderEntitys) {
					Long memberId = contractOrderEntity.getMemberId();
					set.add(memberId);
				}
			}
			if(CollUtil.isNotEmpty(set)) {
				for(long memberIdString : set) {
					//获取每个用户的当前持仓数量
					String count = dataMonitoringMapper.selectContractHoldOrderAccountInToday(format,memberIdString);
					//获取每个用户的历史持仓数量
					String countHistory = dataMonitoringMapper.selectContractOrderAccountInToday(format,memberIdString);
					if(StrUtil.isNotEmpty(count)) {
						int parseInt = Integer.parseInt(count);
						int parseIntHistory = Integer.parseInt(countHistory);
						int allOrder = parseInt + parseIntHistory;
						if(allOrder >= DataMonitoringEntity.ORDER_COUNT_TODAY) {
							//查询是否存在
							Map<String, Object> columnMaps = new HashMap<>();
							columnMaps.put("member_id", memberIdString);
							columnMaps.put("type", 1);
							List<DataMonitoringEntity> selectByMap = dataMonitoringMapper.selectByMap(columnMaps);
							if(CollUtil.isNotEmpty(selectByMap)) {
								DataMonitoringEntity dataMonitoringOne = selectByMap.get(0);
								dataMonitoringOne.setCount(allOrder);
								dataMonitoringOne.setCreateTime(new Date());
								dataMonitoringMapper.updateById(dataMonitoringOne);
							}else {
								DataMonitoringEntity dataMonitoring = new DataMonitoringEntity();
								dataMonitoring.setMemberId(memberIdString);
								dataMonitoring.setCount(allOrder);
								dataMonitoring.setType(1);
								dataMonitoring.setCreateTime(new Date());
								dataMonitoringMapper.insert(dataMonitoring);
							}
						}
					}
				}
			}
		//2---三分钟平仓操作订单超过每日总订单数的50%
		}else if(StrUtil.isNotEmpty(orderType) && orderType.equals("2")){
			//获取【合约持仓订单表】
			Date date = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
			String format = sdf.format(date);
			List<ContractOrderEntity> contractOrderEntitys = dataMonitoringMapper.selectContractOrderListLessThreeInToday(format);
			
			Set<Long> set = new HashSet<>();
			//获取符合条件的今日历史订单数据
			if(CollUtil.isNotEmpty(contractOrderEntitys)) {
				for(ContractOrderEntity contractOderEntity : contractOrderEntitys) {
					Long memberId = contractOderEntity.getMemberId();
					set.add(memberId);
				}
			}
			if(CollUtil.isNotEmpty(set)) {
				for(long memberIdString : set) {
					//获取每个用户的当前持仓数量
					String count = dataMonitoringMapper.selectContractHoldOrderAccountInToday(format,memberIdString);
					//获取每个用户的历史持仓数量
					String countHistory = dataMonitoringMapper.selectContractOrderAccountInToday(format,memberIdString);
					//符合条件的订单数量
					String countIn = dataMonitoringMapper.selectContractOrderListLessThreeCountInToday(format,memberIdString);
					if(StrUtil.isNotEmpty(countIn)) {
						BigDecimal parse = new BigDecimal(count);
						BigDecimal parseHistory = new BigDecimal(countHistory);
						BigDecimal parseIn = new BigDecimal(countIn);
						BigDecimal add = parse.add(parseHistory);
						if(add.compareTo(BigDecimal.ZERO) > 0) {
							BigDecimal divide = parseIn.divide(add,4,BigDecimal.ROUND_HALF_UP);
							double s = divide.doubleValue();
							if(s >= DataMonitoringEntity.ORDER_BILI_TODAY) {
								//查询是否存在
								Map<String, Object> columnMaps = new HashMap<>();
								columnMaps.put("member_id", memberIdString);
								columnMaps.put("type", 2);
								List<DataMonitoringEntity> selectByMap = dataMonitoringMapper.selectByMap(columnMaps);
								if(CollUtil.isNotEmpty(selectByMap)) {
									DataMonitoringEntity dataMonitoringTwo = selectByMap.get(0);
									dataMonitoringTwo.setCount(add.intValue());
									dataMonitoringTwo.setCountOut(parseIn.intValue());
									dataMonitoringTwo.setCreateTime(new Date());
									dataMonitoringMapper.updateById(dataMonitoringTwo);
								}else {
									DataMonitoringEntity dataMonitoring = new DataMonitoringEntity();
									dataMonitoring.setMemberId(memberIdString);
									dataMonitoring.setCount(add.intValue());
									dataMonitoring.setCountOut(parseIn.intValue());
									dataMonitoring.setType(2);
									dataMonitoring.setCreateTime(new Date());
									dataMonitoringMapper.insert(dataMonitoring);
								}
								
							}
						}
					}
				}
			}
		//3：订单总盈亏超过500
		}else if(StrUtil.isNotEmpty(orderType) && orderType.equals("3")){
			Map<String, Object> columnMap = new HashMap<>();
			List<MemberEntity> memberEntitys = memberMapper.selectByMap(columnMap);
			if(CollUtil.isNotEmpty(memberEntitys)) {
				for(MemberEntity memberEntity : memberEntitys) {
					Long id = memberEntity.getId();
					String rewardratioByMid = dataMonitoringMapper.selectRewardratioForBasicRealDataBymid(id);
					BigDecimal subtract = new BigDecimal(rewardratioByMid).subtract(new BigDecimal(DataMonitoringEntity.ORDER_ALLREWARD_TODAY));
					if(subtract.compareTo(BigDecimal.ZERO) > 0 ) {
						//查询是否存在
						Map<String, Object> columnMaps = new HashMap<>();
						columnMaps.put("member_id", id);
						columnMaps.put("type", 3);
						List<DataMonitoringEntity> selectByMap = dataMonitoringMapper.selectByMap(columnMaps);
						if(CollUtil.isNotEmpty(selectByMap)) {
							DataMonitoringEntity dataMonitoringOld = selectByMap.get(0);
							dataMonitoringOld.setReward(new BigDecimal(rewardratioByMid));
							dataMonitoringOld.setCreateTime(new Date());
							dataMonitoringMapper.updateById(dataMonitoringOld);
						}else {
							DataMonitoringEntity dataMonitoring = new DataMonitoringEntity();
							dataMonitoring.setMemberId(id);
							dataMonitoring.setReward(new BigDecimal(rewardratioByMid));
							dataMonitoring.setType(3);
							dataMonitoring.setCreateTime(new Date());
							dataMonitoringMapper.insert(dataMonitoring);
						}
						
					}
				}
			}
			
		}
		
	}
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
}