package com.doumee.service.business.impl;

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.DateUtil;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.*;
import com.doumee.dao.business.join.PlanorderDetailJoinMapper;
import com.doumee.dao.business.model.*;
import com.doumee.service.business.PlanorderDetailService;
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.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;

/**
 * 咖啡计划订单明细表Service实现
 * @author 江蹄蹄
 * @date 2023/03/21 15:48
 */
@Service
public class PlanorderDetailServiceImpl implements PlanorderDetailService {

    @Autowired
    private PlanorderDetailMapper planorderDetailMapper;

    @Autowired
    private GoodsorderDetailMapper goodsorderDetailMapper;

    @Autowired
    private GoodsSkuMapper goodsSkuMapper;

    @Autowired
    private GoodsSkuAttrMapper goodsSkuAttrMapper;

    @Autowired
    private SkuAttrMapper skuAttrMapper;

    @Autowired
    private GoodsMapper goodsMapper;

    @Autowired
    private SkuMapper skuMapper;


    @Autowired
    private PlanorderDetailJoinMapper planorderDetailJoinMapper;

    @Autowired
    private GoodsorderMapper goodsorderMapper;

    @Override
    public Integer create(PlanorderDetail planorderDetail) {
        planorderDetailMapper.insert(planorderDetail);
        return planorderDetail.getId();
    }

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

    @Override
    public void delete(PlanorderDetail planorderDetail) {
        UpdateWrapper<PlanorderDetail> deleteWrapper = new UpdateWrapper<>(planorderDetail);
        planorderDetailMapper.delete(deleteWrapper);
    }

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

    @Override
    public void updateById(PlanorderDetail planorderDetail) {
        planorderDetailMapper.updateById(planorderDetail);
    }

    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void sendOutGoods(PlanorderDetail planorderDetail) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();

        PlanorderDetail query= planorderDetailMapper.selectById(planorderDetail.getId());
        if(query==null){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),ResponseStatus.DATA_EMPTY.getMessage());
        }
        if(!Constants.equalsInteger(query.getStatus(),Constants.ZERO)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"状态已流转，禁止操作！");
        }
        planorderDetail.setEditor(user.getId());
        planorderDetail.setEditDate(new Date());
        planorderDetail.setStatus(Constants.ONE);
        planorderDetail.setKdDate(new Date());
        planorderDetail.setKdUser(user.getId());
        planorderDetailMapper.updateById(planorderDetail);

        /**--------------------start判断是否已全部完成发货,更新主订单表状态-------------------------*/
        PlanorderDetail queryParam=new PlanorderDetail();
        queryParam.setOrderId(query.getOrderId());
        queryParam.setIsdeleted(Constants.ZERO);
        List<PlanorderDetail> queryList=planorderDetailMapper.selectList(new QueryWrapper<>(queryParam));
        if(queryList!=null&&queryList.size()>0){
            Boolean isFinish=false;
            Integer isFirst=0;
            for(int i=0;i<queryList.size();i++){
                PlanorderDetail pd=queryList.get(i);
                if(Constants.equalsInteger(pd.getStatus(),Constants.ZERO)||Constants.equalsInteger(pd.getStatus(),Constants.TWO)){
                    isFinish=true;
                }else{
                    isFirst++;
                }
            }
            if(isFirst==1){
                //首次发货更新订单表为部分发货
                Goodsorder goodsorder=new Goodsorder();
                goodsorder.setId(query.getOrderId());
                goodsorder.setStatus(Constants.OrderStatus.PART_DONE.getKey());
                goodsorder.setEditDate(new Date());
                goodsorder.setEditor(user.getId());

                goodsorderMapper.updateById(goodsorder);
            }

            if(!isFinish){
                //完成发货
                Goodsorder goodsorder=new Goodsorder();
                goodsorder.setId(query.getOrderId());
                goodsorder.setStatus(Constants.OrderStatus.DONE.getKey());
                goodsorder.setEditDate(new Date());
                goodsorder.setEditor(user.getId());
                goodsorder.setDoneDate(new Date());
                goodsorder.setDoneInfo(Constants.OrderStatus.DONE.getNoteinfo());
                goodsorderMapper.updateById(goodsorder);
            }
        }
        /**--------------------end判断是否已全部完成发货,更新主订单表状态-------------------------*/
    }

    @Override
    public void updateByIdInBatch(List<PlanorderDetail> planorderDetails) {
        if (CollectionUtils.isEmpty(planorderDetails)) {
            return;
        }
        for (PlanorderDetail planorderDetail: planorderDetails) {
            this.updateById(planorderDetail);
        }
    }

    @Override
    public PlanorderDetail findById(Integer id) {
        return planorderDetailMapper.selectById(id);
    }

    @Override
    public PlanorderDetail findOne(PlanorderDetail planorderDetail) {
        QueryWrapper<PlanorderDetail> wrapper = new QueryWrapper<>(planorderDetail);
        return planorderDetailMapper.selectOne(wrapper);
    }

    @Override
    public List<PlanorderDetail> findList(PlanorderDetail planorderDetail) {
        QueryWrapper<PlanorderDetail> wrapper = new QueryWrapper<>(planorderDetail);
        return planorderDetailMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<PlanorderDetail> findPage(PageWrap<PlanorderDetail> pageWrap) {
        IPage<PlanorderDetail> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        MPJLambdaWrapper<PlanorderDetail> queryWrapper = new MPJLambdaWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());

        queryWrapper.selectAs(Member::getNickname,PlanorderDetail::getNikeName);
        queryWrapper.selectAs(Member::getPhone,PlanorderDetail::getPhone);
        queryWrapper.selectAs(Addr::getAddr,PlanorderDetail::getAddr);
        queryWrapper.select( " (select count(gd.id) from planorder_detail gd where gd.ORDER_ID=t.ORDER_ID and gd.ISDELETED=0) as sortAllnum" );

        queryWrapper.leftJoin(Goodsorder.class,Goodsorder::getId,PlanorderDetail::getOrderId);
        queryWrapper.leftJoin(Member.class,Member::getId,Goodsorder::getMemberId);
        queryWrapper.leftJoin(Addr.class,Addr::getMemberId,Member::getId);
        queryWrapper.eq(Addr::getIsDefault,Constants.ONE);//展示默认的发货地址

        queryWrapper.and(StringUtils.isNotBlank(pageWrap.getModel().getNikeName()) ,ms->ms.like(Member::getNickname,pageWrap.getModel().getNikeName())
        .or().like(Member::getPhone,pageWrap.getModel().getNikeName())
        );
        queryWrapper.eq(pageWrap.getModel().getOrderId()!=null,PlanorderDetail::getOrderId,pageWrap.getModel().getOrderId());

        queryWrapper.le(PlanorderDetail::getCreateDate,DateUtil.getCurrentDate());
        queryWrapper.eq(PlanorderDetail::getStatus,Constants.ZERO);//展示代发货的数据
        queryWrapper.eq(PlanorderDetail::getIsdeleted,Constants.ZERO);
        queryWrapper.orderByDesc(PlanorderDetail::getCreateDate);

        IPage<PlanorderDetail> result = planorderDetailJoinMapper.selectJoinPage(page, PlanorderDetail.class, queryWrapper);

        return PageData.from(result);
    }

    @Override
    public long count(PlanorderDetail planorderDetail) {
        QueryWrapper<PlanorderDetail> wrapper = new QueryWrapper<>(planorderDetail);
        return planorderDetailMapper.selectCount(wrapper);
    }


    /****************************************移动端接口开始********************************************************************/
    /**
     * 生成咖啡计划数据
     * @param goodsorder
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void createPlanOrderDetail(Goodsorder goodsorder){
        GoodsorderDetail goodsorderDetail =   goodsorderDetailMapper.selectOne(new QueryWrapper<GoodsorderDetail>()
                .eq("ORDER_ID",goodsorder.getId())
                .last(" limit 1  ")
        );
        Integer monthNum = Constants.ZERO ;
        //查询规格信息
        GoodsSku goodsSku = goodsSkuMapper.selectById(goodsorderDetail.getGoodsSkuId());
        if(Objects.isNull(goodsSku)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到商品SKU规格组信息！");
        }
        GoodsSkuAttr goodsSkuAttr = goodsSkuAttrMapper.selectOne(new QueryWrapper<GoodsSkuAttr>().eq("GOODS_SKU_ID",goodsSku.getId()));
        if(Objects.isNull(goodsSkuAttr)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到商品规格组信息！");
        }
        SkuAttr skuAttr = skuAttrMapper.selectById(goodsSkuAttr.getSkuAttrId());
        if(!Objects.isNull(skuAttr)){
            monthNum = skuAttr.getMonthNum();
        }
        Sku sku = skuMapper.selectById(skuAttr.getSkuId());
        if(Objects.isNull(sku)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到商品主规格信息！");
        }
        Goods goods = goodsMapper.selectById(sku.getGoodsId());
        if(Objects.isNull(goods)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到商品信息！");
        }
        Integer planOrderType = goodsorder.getPlanOrderType();
        Date beginDate = new Date();
        if(planOrderType.equals(Constants.ONE)){
            //咖啡计划订单形式 延长 则查询最后一笔订单的计划日期
            Date lastDate = this.planorderDetailMapper.getMaxPlanDate(goodsorder.getCreator(),goodsSku.getGoodsId());
            if(!Objects.isNull(lastDate)){
                beginDate = lastDate;
            }
        }
        for (int i = 1; i <= monthNum; i++) {
            beginDate = DateUtil.addDaysToDate(beginDate,15);
            PlanorderDetail planorderDetail = new PlanorderDetail();
            planorderDetail.setCreator(goodsorder.getCreator());
            planorderDetail.setCreateDate(new Date());
            planorderDetail.setIsdeleted(Constants.ZERO);
            planorderDetail.setOrderId(goodsorder.getId());
            planorderDetail.setSortnum(i);
            planorderDetail.setStatus(Constants.ZERO);
            planorderDetail.setGoodsName(goods.getName());
            planorderDetail.setAttrName(goodsSku.getName());
            planorderDetail.setKdPlanDate(beginDate);
            planorderDetailMapper.insert(planorderDetail);
        }
    }



}