package com.doumee.service.business.impl;

import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.IntegralMapper;
import com.doumee.dao.business.MemberMapper;
import com.doumee.dao.business.join.IntegralJoinMapper;
import com.doumee.dao.business.model.Fund;
import com.doumee.dao.business.model.Integral;
import com.doumee.dao.business.model.Member;
import com.doumee.dao.web.dto.IntegralDTO;
import com.doumee.dao.web.request.DealIntegralRequest;
import com.doumee.service.business.AreasService;
import com.doumee.service.business.IntegralService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 用户积分明细表Service实现
 *
 * @author 江蹄蹄
 * @date 2023/03/21 15:48
 */
@Service
public class IntegralServiceImpl implements IntegralService {

    @Autowired
    private IntegralMapper integralMapper;

    @Autowired
    private IntegralJoinMapper integralJoinMapper;

    @Autowired
    private SystemDictDataBiz systemDictDataBiz;

    @Autowired
    private MemberMapper memberMapper;

    @Transactional(rollbackFor = {Exception.class, BusinessException.class})
    @Override
    public Integer createUpIntegral(Integral integral) {
//        LoginUserInfo userInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();

        Member member = memberMapper.selectById(integral.getMemberId());
        Integral insert = new Integral();
//        insert.setCreator(userInfo.getId());
//        insert.setEditor(userInfo.getId());
        insert.setRemark(integral.getRemark());
        insert.setMemberId(integral.getMemberId());
        insert.setTitle(integral.getTitle());
        insert.setContent(integral.getContent());
        insert.setObjId(integral.getObjId());
        insert.setObjType(integral.getObjType());
        insert.setType(integral.getType());
        insert.setNum(integral.getNum());
        insert.setTotalNum(member.getIntegral());
        insert.setOrderCode(integral.getOrderCode());

        BigDecimal result = Constants.equalsInteger(integral.getType(),Constants.ZERO)
                ? member.getIntegral().add(integral.getNum()):member.getIntegral().subtract(integral.getNum());
        //防止数据被修改增加时间戳
        UpdateWrapper<Member> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(Member::getId,member.getId())
                                .eq(Member::getEditDate,member.getEditDate())
                                .set(Member::getIntegral,result)
                                .set(Member::getIntegral,member.getTotalIntegral().add(integral.getNum()))
                                .set(Member::getEditDate,new Date());
        int update = memberMapper.update(null, updateWrapper);
        if (update < 1){
            throw new BusinessException(ResponseStatus.MASSIVE_REQUEST.getCode(),"新增积分失败");
        }
        integralMapper.insert(integral);
        return integral.getId();
    }

    @Override
    @Transactional(rollbackFor = {Exception.class, BusinessException.class})
    public Integer createDownIntegral(Integral integral,Integer memberId) {
//        LoginUserInfo userInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        Member member = memberMapper.selectById(memberId);
        Integral insert = new Integral();
//        insert.setCreator(userInfo.getId());
//        insert.setEditor(userInfo.getId());
        insert.setRemark(integral.getRemark());
        insert.setMemberId(member.getId());
        insert.setTitle(integral.getTitle());
        insert.setContent(integral.getContent());
        insert.setObjId(integral.getObjId());
        insert.setObjType(integral.getObjType());
        insert.setType(Constants.ZERO);
        insert.setNum(integral.getNum());
        insert.setTotalNum(member.getIntegral());
        insert.setOrderCode(integral.getOrderCode());

        //防止数据被修改 增加时间戳
        UpdateWrapper<Member> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lambda().eq(Member::getId,member.getId())
                .eq(Member::getEditDate,member.getEditDate())
                .set(Member::getIntegral,member.getIntegral().subtract(integral.getNum()))
                .set(Member::getEditDate,new Date());
        int update = memberMapper.update(null, updateWrapper);
        if (update < 1){
            throw new BusinessException(ResponseStatus.MASSIVE_REQUEST.getCode(),"消费积分失败");
        }
        integralMapper.insert(integral);
        return integral.getId();
    }


    @Override
    @Transactional(rollbackFor = {Exception.class, BusinessException.class})
    public Integer dealIntegral(DealIntegralRequest dealIntegralRequest) {
        Member member = memberMapper.selectById(dealIntegralRequest.getMemberId());
        if(Objects.isNull(member)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到用户信息");
        }
        Integral integral = new Integral();
        integral.setMemberId(member.getId());
        integral.setCreateDate(new Date());
        integral.setCreator(member.getId());
        integral.setIsdeleted(Constants.ZERO);
        integral.setTitle(dealIntegralRequest.getIntegralObjType().getName());
        integral.setContent(dealIntegralRequest.getIntegralObjType().getNoteinfo());
        integral.setObjId(dealIntegralRequest.getObjId());
        integral.setObjType(dealIntegralRequest.getIntegralObjType().getKey());
        integral.setType(dealIntegralRequest.getDealType());
        integral.setNum(dealIntegralRequest.getIntegralNum());
        integral.setTotalNum(dealIntegralRequest.getDealType().equals(Constants.ZERO)? member.getIntegral().add(integral.getNum()):member.getIntegral().subtract(integral.getNum()));
        integral.setOrderCode(dealIntegralRequest.getOrderCode());
        integralMapper.insert(integral);
        if(dealIntegralRequest.getDealType().equals(Constants.ZERO)){
            memberMapper.addIntegral(member.getId(),dealIntegralRequest.getIntegralNum(),
                    dealIntegralRequest.getIntegralObjType().getAddTitle()==Constants.ZERO?dealIntegralRequest.getIntegralNum():BigDecimal.ZERO);
        }else{
            memberMapper.subtractIntegral(member.getId(),dealIntegralRequest.getIntegralNum());
        }
        return integral.getId();
    }




    @Override
    public void deleteById(Integer id) {
        integralMapper.deleteById(id);
    }


    @Override
    public BigDecimal getMonthlyMoney() {
        MPJLambdaWrapper<Integral> queryWrapper = new MPJLambdaWrapper<>();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        Calendar c = Calendar.getInstance();
        c.add(Calendar.MONTH,-1);
        Date month = c.getTime();
        String lastmonth=sdf.format(month);//上个月
        queryWrapper.select("(select sum(z.TOTAL_NUM) from " +
                " (select  a.TOTAL_NUM from (select s.TOTAL_NUM,s.MEMBER_ID from integral s where s.TYPE=0 and s.ISDELETED=0 " +
                " and DATE_FORMAT( LAST_DAY(DATE_SUB(CURDATE(), INTERVAL 1 MONTH)), '%Y-%m')= DATE_FORMAT(s.CREATE_DATE, '%Y-%m') " +
                " ORDER BY s.CREATE_DATE desc ) a " +
                " GROUP BY a.MEMBER_ID) z) as totalNum ");
        queryWrapper.eq(Integral::getIsdeleted,Constants.ZERO);
        queryWrapper.eq(Integral::getType,Constants.ZERO);
        queryWrapper.eq("DATE_FORMAT(t.CREATE_DATE, '%Y-%m')",lastmonth);
        queryWrapper.last("limit 1");
        Integral integral=  integralJoinMapper.selectJoinOne(Integral.class,queryWrapper);
        if(Objects.nonNull(integral)&&integral.getTotalNum()!=null){
            return integral.getTotalNum();
        }else{
            return BigDecimal.valueOf(0);
        }

    }

    @Override
    public void delete(Integral integral) {
        UpdateWrapper<Integral> deleteWrapper = new UpdateWrapper<>(integral);
        integralMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        integralMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(Integral integral) {
        integralMapper.updateById(integral);
    }

    @Override
    public void updateByIdInBatch(List<Integral> integrals) {
        if (CollectionUtils.isEmpty(integrals)) {
            return;
        }
        for (Integral integral : integrals) {
            this.updateById(integral);
        }
    }

    @Override
    public Integral findById(Integer id) {
        return integralMapper.selectById(id);
    }

    @Override
    public Integral findOne(Integral integral) {
        QueryWrapper<Integral> wrapper = new QueryWrapper<>(integral);
        return integralMapper.selectOne(wrapper);
    }

    @Override
    public List<Integral> findList(Integral integral) {
        QueryWrapper<Integral> wrapper = new QueryWrapper<>(integral);
        return integralMapper.selectList(wrapper);
    }

    @Override
    public PageData<Integral> findPage(PageWrap<Integral> pageWrap) {
        IPage<Integral> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        MPJLambdaWrapper<Integral> queryWrapper = new MPJLambdaWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());

        queryWrapper.selectAll(Integral.class);
        queryWrapper.selectAs(Member::getNickname, Fund::getNickName);
        queryWrapper.selectAs(Member::getImgurl, Fund::getImgurl);
        queryWrapper.selectAs(Member::getPhone, Fund::getPhone);

        queryWrapper.leftJoin(Member.class, Member::getId, Integral::getMemberId);

        queryWrapper.eq(pageWrap.getModel().getMemberId() != null, Integral::getMemberId, pageWrap.getModel().getMemberId());
        queryWrapper.eq(pageWrap.getModel().getType() != null, Integral::getType, pageWrap.getModel().getType());
        queryWrapper.and(StringUtils.isNotBlank(pageWrap.getModel().getNickName()), ms -> ms.like(Member::getNickname, pageWrap.getModel().getNickName())
                .or().like(Member::getPhone, pageWrap.getModel().getNickName())
        );
        queryWrapper.like( StringUtils.isNotBlank(pageWrap.getModel().getOrderCode()), Integral::getOrderCode, pageWrap.getModel().getOrderCode());
        queryWrapper.like( StringUtils.isNotBlank(pageWrap.getModel().getContent()), Integral::getContent, pageWrap.getModel().getContent());

        if (pageWrap.getModel().getStarttime() != null) {
            queryWrapper.ge(Integral::getCreateDate, pageWrap.getModel().getStarttime());
        }
        if (pageWrap.getModel().getEndtime() != null) {
            queryWrapper.le(Integral::getCreateDate, pageWrap.getModel().getEndtime());
        }
        queryWrapper.orderByDesc(Integral::getCreateDate);
        IPage<Integral> result = integralJoinMapper.selectJoinPage(page, Integral.class, queryWrapper);

        String path = systemDictDataBiz.queryByCode(Constants.OSS, Constants.RESOURCE_PATH).getCode() + systemDictDataBiz.queryByCode(Constants.OSS, Constants.MEMBER_FILE).getCode();
        for (Integral model : result.getRecords()) {
            if (StringUtils.isNotBlank(model.getImgurl())) {
                model.setImgurl(path + model.getImgurl());
            }
        }
        return PageData.from(result);
    }

    @Override
    public long count(Integral integral) {
        QueryWrapper<Integral> wrapper = new QueryWrapper<>(integral);
        return integralMapper.selectCount(wrapper);
    }

    @Override
    public PageData<IntegralDTO> findIntegralDTOPage(PageWrap<IntegralDTO> pageWrap,Integer memberId) {
//        LoginUserInfo info = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        IPage<Integral> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<Integral> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        queryWrapper.lambda().eq(Integral::getMemberId,memberId)
                                .eq(Objects.nonNull(pageWrap.getModel().getType()),Integral::getType,pageWrap.getModel().getType())
                                .orderByDesc(Integral::getCreateDate);

        IPage<Integral> result = integralMapper.selectPage(page,queryWrapper);
        if (CollectionUtils.isEmpty(result.getRecords())){
            return PageData.from(new Page<>());
        }
        List<IntegralDTO> collect = result.getRecords().stream().map(s -> {
            IntegralDTO dto = new IntegralDTO();
            dto.setId(s.getId());
            dto.setCreateDate(s.getCreateDate());
            dto.setTitle(s.getTitle());
            dto.setType(s.getType());
            dto.setNum(s.getNum());
            dto.setTotalNum(s.getTotalNum());
            return dto;
        }).collect(Collectors.toList());
        IPage<IntegralDTO>  integralDTOIPage = new Page<>();
        integralDTOIPage.setPages(result.getPages());
        integralDTOIPage.setRecords(collect);
        integralDTOIPage.setTotal(result.getTotal());
        integralDTOIPage.setSize(result.getSize());
        integralDTOIPage.setCurrent(result.getCurrent());
        return PageData.from(integralDTOIPage);
    }
}