package com.nq.service.impl;


import com.nq.dao.*;
import com.nq.enums.EStockType;
import com.nq.enums.EUserAssets;
import com.nq.pojo.*;
import com.nq.service.*;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.nq.common.ServerResponse;
import com.nq.utils.timeutil.DateTimeUtil;
import com.nq.utils.KeyUtils;
import com.nq.utils.redis.RedisShardedPoolUtils;

import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.Date;
import java.util.List;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service("iUserRechargeService")
public class UserRechargeServiceImpl implements IUserRechargeService {
    private static final Logger log = LoggerFactory.getLogger(UserRechargeServiceImpl.class);

    @Resource
    UserRechargeMapper userRechargeMapper;

    @Autowired
    IUserService iUserService;

    @Resource
    UserMapper userMapper;

    @Autowired
    IAgentUserService iAgentUserService;
    @Resource
    AgentUserMapper agentUserMapper;
    @Autowired
    ISiteSettingService iSiteSettingService;

    @Resource
    SitePayMapper sitePayMapper;

    @Autowired
    IUserAssetsServices userAssetsServices;


    @Autowired
    ISiteInfoService iSiteInfoService;

    public ServerResponse checkInMoney(int maxOrder, Integer userId) {
        int count = this.userRechargeMapper.checkInMoney(0, userId);

        if (count > maxOrder) {
            return ServerResponse.createByErrorMsg("一小时内只能发起" + maxOrder + "次入金");
        }
        return ServerResponse.createBySuccess();
    }


    public ServerResponse inMoney(String amt, String payType, HttpServletRequest request) {
        if (StringUtils.isBlank(amt) || StringUtils.isBlank(payType)) {
            return ServerResponse.createByErrorMsg("The parameter cannot be null");
        }

        SiteSetting siteSetting = this.iSiteSettingService.getSiteSetting();
        if (siteSetting == null) {
            return ServerResponse.createByErrorMsg("set is not initialized");
        }
        if ((new BigDecimal(siteSetting.getChargeMinAmt() + "")).compareTo(new BigDecimal(amt)) == 1) {
            return ServerResponse.createByErrorMsg("The top-up amount shall not be less than" + siteSetting.getChargeMinAmt());
        }


        SiteInfo siteInfo = null;
        ServerResponse serverResponseInfo = this.iSiteInfoService.getInfo(request);
        if (serverResponseInfo.isSuccess()) {
            siteInfo = (SiteInfo) serverResponseInfo.getData();
            /*if (StringUtils.isBlank(siteInfo.getSiteHost()) ||
                    StringUtils.isBlank(siteInfo.getSiteEmailTo())) {
                return ServerResponse.createByErrorMsg("请先设置Host and ToEmail");
            }*/
        } else {
            return serverResponseInfo;
        }

        User user = this.iUserService.getCurrentRefreshUser(request);
        if (user.getIsActive().intValue() != 2) {
            return ServerResponse.createByErrorMsg("Recharge cannot be initiated without real-name authentication");
        }


        ServerResponse serverResponse = checkInMoney(10, user.getId());
        if (!serverResponse.isSuccess()) {
            return serverResponse;
        }


        UserRecharge userRecharge = new UserRecharge();

        userRecharge.setUserId(user.getId());
        userRecharge.setNickName(user.getRealName());
        userRecharge.setAgentId(user.getAgentId());

        String ordersn = KeyUtils.getRechargeOrderSn();
        userRecharge.setOrderSn(ordersn);

        userRecharge.setPayChannel(payType);
        userRecharge.setPayAmt(new BigDecimal(amt));
        userRecharge.setOrderStatus(Integer.valueOf(0));
        userRecharge.setAddTime(new Date());

        int insertCount = this.userRechargeMapper.insert(userRecharge);
        if (insertCount > 0) {

            String email_token = KeyUtils.getUniqueKey();

            String redisSetExResult = RedisShardedPoolUtils.setEx(email_token, email_token, 300);

            log.info("用户充值，保存redis token成功，redisSetExResult = {}", redisSetExResult);

            /*SendHTMLMail.send(user, userRecharge, email_token, siteInfo
                    .getSiteHost(), siteInfo.getSiteEmailTo());
            log.info("用户充值，发送审核邮件成功");*/
            return ServerResponse.createBySuccessMsg("Creating a payment order succeeded！");
        }
        return ServerResponse.createByErrorMsg("Failed to create a payment order");
    }


    public ServerResponse findUserRechargeByOrderSn(String orderSn) {
        UserRecharge userRecharge = this.userRechargeMapper.findUserRechargeByOrderSn(orderSn);
        if (userRecharge != null) {
            return ServerResponse.createBySuccess(userRecharge);
        }
        return ServerResponse.createByErrorMsg("找不到充值订单");
    }


    @Transactional(rollbackFor = Exception.class)
    public ServerResponse chargeSuccess(UserRecharge userRecharge) throws Exception {
        log.info("充值订单 确认成功操作 id = {}", userRecharge.getId());

        if (userRecharge.getOrderStatus().intValue() != 0) {
            return ServerResponse.createByErrorMsg("订单状态不能重复修改");
        }


        User user = this.userMapper.selectById(userRecharge.getUserId());
        if (user == null) {
            return ServerResponse.createByErrorMsg("用户不存在");
        }
        int updateCount = this.userMapper.updateById(user);
        if (updateCount > 0) {
            log.info("1.修改用户资金成功");
        } else {
            return ServerResponse.createByErrorMsg("失败，修改用户资金失败");
        }


        userRecharge.setOrderStatus(Integer.valueOf(1));
        userRecharge.setPayTime(new Date());
        int updateCCount = this.userRechargeMapper.updateByPrimaryKeySelective(userRecharge);
        if (updateCCount > 0) {
            log.info("2.修改订单状态成功");
        } else {
            throw new Exception("2. 修改订单状态失败!");
        }


        return ServerResponse.createByErrorMsg("充值失败");
    }


    public ServerResponse chargeFail(UserRecharge userRecharge) throws Exception {
        if (userRecharge.getOrderStatus().intValue() != 0) {
            return ServerResponse.createByErrorMsg("订单状态不能重复修改");
        }

        userRecharge.setOrderStatus(Integer.valueOf(2));
        int updateCCount = this.userRechargeMapper.updateByPrimaryKeySelective(userRecharge);
        if (updateCCount > 0) {
            return ServerResponse.createBySuccessMsg("订单已修改为失败");
        }
        return ServerResponse.createByErrorMsg("修改出现异常");
    }


    public ServerResponse chargeCancel(UserRecharge userRecharge) throws Exception {
        if (userRecharge.getOrderStatus().intValue() != 0) {
            return ServerResponse.createByErrorMsg("订单状态不能重复修改");
        }

        userRecharge.setOrderStatus(Integer.valueOf(3));
        int updateCCount = this.userRechargeMapper.updateByPrimaryKeySelective(userRecharge);
        if (updateCCount > 0) {
            return ServerResponse.createBySuccessMsg("订单取消成功");
        }
        return ServerResponse.createByErrorMsg("订单取消出现异常");
    }


    public ServerResponse<PageInfo> findUserChargeList(String payChannel, String orderStatus, HttpServletRequest request, int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);

        User user = this.iUserService.getCurrentUser(request);
        List<UserRecharge> userRecharges = this.userRechargeMapper.findUserChargeList(user.getId(), payChannel, orderStatus);
        PageInfo pageInfo = new PageInfo(userRecharges);

        for (int i = 0; i <userRecharges.size() ; i++) {
            //SitePay s =   sitePayMapper.selectById(userRecharges.get(i).getPayId());
            if (StringUtils.isNotBlank(userRecharges.get(i).getAssetsType())) {
                EStockType eStockType = EStockType.getEStockTypeByCode(userRecharges.get(i).getAssetsType());
                userRecharges.get(i).setAssetsType(eStockType.getSymbol1());
                userRecharges.get(i).setChannelName(eStockType.getSymbol());
            } else {
                userRecharges.get(i).setAssetsType(EStockType.getDefault().getSymbol1());
                userRecharges.get(i).setChannelName(EStockType.getDefault().getSymbol());
            }

        }

        return ServerResponse.createBySuccess(pageInfo);
    }


    public ServerResponse<PageInfo> listByAgent(Integer agentId, String realName, String payChannel, Integer state, HttpServletRequest request, int pageNum, int pageSize) {
        AgentUser currentAgent = this.iAgentUserService.getCurrentAgent(request);


        if (agentId != null) {
            AgentUser agentUser = this.agentUserMapper.selectByPrimaryKey(agentId);
            if (agentUser.getParentId() != currentAgent.getId()) {
                return ServerResponse.createByErrorMsg("不能查询非下级代理记录");
            }
        }
        Integer searchId = null;
        if (agentId == null) {
            searchId = currentAgent.getId();
        } else {
            searchId = agentId;
        }


        PageHelper.startPage(pageNum, pageSize);


        List<UserRecharge> userRecharges = this.userRechargeMapper.listByAgent(searchId, realName, payChannel, state);

        PageInfo pageInfo = new PageInfo(userRecharges);

        return ServerResponse.createBySuccess(pageInfo);
    }


    public ServerResponse listByAdmin(Integer agentId, Integer userId, String realName, Integer state, String beginTime, String endTime, HttpServletRequest request, int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);


        Timestamp begin_time = null;
        if (StringUtils.isNotBlank(beginTime)) {
            begin_time = DateTimeUtil.searchStrToTimestamp(beginTime);
        }
        Timestamp end_time = null;
        if (StringUtils.isNotBlank(endTime)) {
            end_time = DateTimeUtil.searchStrToTimestamp(endTime);
        }


        List<UserRecharge> userRecharges = this.userRechargeMapper.listByAdmin(agentId, userId, realName, state, begin_time, end_time);
        for (int i = 0; i < userRecharges.size(); i++) {
            UserRecharge u =userRecharges.get(i);
            User user =  userMapper.selectById(u.getUserId());
            if(user != null){
                u.setUserPhone(user.getPhone());
                u.setNickName(user.getRealName());
            }

        }
        PageInfo pageInfo = new PageInfo(userRecharges);

        return ServerResponse.createBySuccess(pageInfo);
    }


    @Transactional(rollbackFor = Exception.class)
    public ServerResponse updateState(Integer chargeId, Integer state) throws Exception {
        UserRecharge userRecharge = this.userRechargeMapper.selectById(chargeId);

        if (userRecharge == null) {
            return ServerResponse.createByErrorMsg("充值订单不存在");
        }
        if (userRecharge.getOrderStatus().intValue() != 0) {
            return ServerResponse.createByErrorMsg("订单状态不是下单状态不能更改");
        }


        if (state.intValue() == 1) {
            User user = this.userMapper.selectById(userRecharge.getUserId());
            if (user == null) {
                return ServerResponse.createByErrorMsg("用户不存在");
            }
            SitePay payChnnel = sitePayMapper.selectById(userRecharge.getPayId());
            userAssetsServices.availablebalanceChange(payChnnel.getAssetsType(),user.getId(), EUserAssets.TOP_UP,userRecharge.getPayAmt(),"","");
        }
        userRecharge.setOrderStatus(Integer.valueOf((state.intValue() == 1) ? 1 : 2));
        userRecharge.setPayTime(new Date());
        int updateCount = this.userRechargeMapper.updateByPrimaryKeySelective(userRecharge);
        if (updateCount > 0) {
            return ServerResponse.createBySuccessMsg("修改订单状态成功！");
        }
        return ServerResponse.createByErrorMsg("修改订单状态失败！");
    }


    public ServerResponse createOrder(Integer userId, Integer state, Integer amt, String payChannel, String accectType) {
        if (userId == null || state == null || amt == null) {
            return ServerResponse.createByErrorMsg("参数不能为空");
        }
        if (accectType == null || accectType.isEmpty()) {
            accectType = EStockType.getDefault().getCode();
        }
        try {
            User user = this.userMapper.selectById(userId);
            if (user == null) {
                return ServerResponse.createByErrorMsg("找不到用户");
            }

            UserRecharge userRecharge = new UserRecharge();
            userRecharge.setUserId(user.getId());
            userRecharge.setNickName(user.getRealName());
            userRecharge.setAgentId(user.getAgentId());

            String ordersn = KeyUtils.getRechargeOrderSn();
            userRecharge.setOrderSn(ordersn);

            userRecharge.setPayChannel(payChannel);
            userRecharge.setPayAmt(new BigDecimal(amt.intValue()));
            userRecharge.setAddTime(new Date());
            userRecharge.setPayTime(new Date());
            userRecharge.setOrderStatus(Integer.valueOf(1));
            userRecharge.setPayId(1);
            userRecharge.setAssetsType(accectType);
            userAssetsServices.availablebalanceChange(accectType,
                    userId,EUserAssets.TOP_UP,new BigDecimal(amt),"","");
            int insertCount = this.userRechargeMapper.insert(userRecharge);
            if (insertCount > 0) {
                return ServerResponse.createBySuccessMsg("生成订单成功！");
            }
            return ServerResponse.createByErrorMsg("生成订单失败，请重试");
        } catch (Exception e) {
            return ServerResponse.createByErrorMsg(e.getMessage());
        }
    }


    public ServerResponse del(Integer cId) {
        if (cId == null) {
            return ServerResponse.createByErrorMsg("id不能为空");
        }
        int updateCount = this.userRechargeMapper.deleteById(cId);
        if (updateCount > 0) {
            return ServerResponse.createBySuccessMsg("删除成功");
        }
        return ServerResponse.createByErrorMsg("删除失败");
    }


    public int deleteByUserId(Integer userId) {
        return this.userRechargeMapper.deleteByUserId(userId);
    }


    public BigDecimal CountChargeSumAmt(Integer chargeState) {
        return this.userRechargeMapper.CountChargeSumAmt(chargeState);
    }

    public BigDecimal CountTotalRechargeAmountByTime(Integer chargeState) {
        return this.userRechargeMapper.CountTotalRechargeAmountByTime(chargeState);
    }

    @Override
    public List<UserRecharge> exportByAdmin(Integer agentId, Integer userId, String realName, Integer state, String beginTime, String endTime, HttpServletRequest request) {
        Timestamp begin_time = null;
        if (StringUtils.isNotBlank(beginTime)) {
            begin_time = DateTimeUtil.searchStrToTimestamp(beginTime);
        }
        Timestamp end_time = null;
        if (StringUtils.isNotBlank(endTime)) {
            end_time = DateTimeUtil.searchStrToTimestamp(endTime);
        }


        List<UserRecharge> userRecharges = this.userRechargeMapper.listByAdmin(agentId, userId, realName, state, begin_time, end_time);

        return userRecharges;
    }

    @Override
    public int countPendingRecharge() {
        com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<UserRecharge> queryWrapper = new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();
        queryWrapper.eq("order_status", 0);
        return this.userRechargeMapper.selectCount(queryWrapper).intValue();
    }
}