package com.xzx.gc.user.service;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.StrUtil;
import com.google.common.collect.Ordering;
import com.xzx.gc.common.constant.Constants;
import com.xzx.gc.common.constant.OrderEnum;
import com.xzx.gc.common.utils.BusinessUtil;
import com.xzx.gc.common.utils.DateUtils;
import com.xzx.gc.entity.OrderInfo;
import com.xzx.gc.entity.OrderItemInfo;
import com.xzx.gc.model.order.OrderInfoVo;
import com.xzx.gc.user.dto.RecycleStatistic;
import com.xzx.gc.user.mapper.OrderDetailMapper;
import com.xzx.gc.user.mapper.OrderMapper;
import com.xzx.gc.user.mapper.SysEnvironmentalInfoMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import tk.mybatis.mapper.entity.Example;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
@Transactional
@Slf4j
public class OrderService {

    @Autowired
    private  OrderMapper orderMapper;


    /**
     * 统计今天和累计的回收重量和金钱
     * @param type 1为用户 其他为回收员
     * @return
     */
    public RecycleStatistic findOrderItemInfo(String userId,int type){

        RecycleStatistic recycleStatistic=null;

        List<OrderItemInfo> list=orderMapper.findOrderItemInfo(userId,type);


        BigDecimal money=BigDecimal.ZERO;
        BigDecimal moneyToday=BigDecimal.ZERO;
        BigDecimal weight=BigDecimal.ZERO;
        BigDecimal weightToday=BigDecimal.ZERO;
        if(!CollectionUtils.isEmpty(list)){
            for (OrderItemInfo orderItemInfo : list) {
                money=NumberUtil.add(money,Convert.toBigDecimal(orderItemInfo.getMoney(),Constants.MONEY_INIT));
                weight=NumberUtil.add(weight,Convert.toBigDecimal(orderItemInfo.getWeight(),Constants.WEIGHT_INIT));


                String s = DateUtil.parse(orderItemInfo.getCreateTime(), DateUtils.DATE_FORMAT_YMD).toDateStr();
                if(DateUtil.format(new Date(),DateUtils.DATE_FORMAT_YMD).equals(s)){
                    moneyToday=NumberUtil.add(moneyToday,Convert.toBigDecimal(orderItemInfo.getMoney(),Constants.MONEY_INIT));
                    weightToday=NumberUtil.add(weightToday,Convert.toBigDecimal(orderItemInfo.getWeight(),Constants.WEIGHT_INIT));
                }
            }

            recycleStatistic=new RecycleStatistic();
            recycleStatistic.setMoneyAll(Convert.toStr(money));
            recycleStatistic.setWeightAll(Convert.toStr(weight));
            recycleStatistic.setWeightToday(Convert.toStr(weightToday));
            recycleStatistic.setMoneyToday(Convert.toStr(moneyToday));

        }

        return  recycleStatistic;

    }




    /**
     * 查询回收员是否有正在操作的单
     * @param receiver
     * @return
     */
    public List<OrderInfo> findByManageReceiver(String receiver){
        //当删除回收员需要判断是否有订单存在
        Example example = new Example(OrderInfo.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("receiver", receiver);
        List<String> list = new ArrayList<>();
        list.add(OrderEnum.待入库.getValue());
        list.add(OrderEnum.服务中.getValue());
        criteria.andIn("orderStatus", list);
        List<OrderInfo> list1 = orderMapper.selectByExample(example);
        return list1;
    }


    /**
     *
     * @param userId
     * @param time
     * @param type
     * @return
     */
    public int findByCreateTime(String userId,String time,int type){
        Example example = new Example(OrderInfo.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("createUserId", userId);
        List<String> list = new ArrayList<>();
        list.add(OrderEnum.待入库.getValue());
        list.add(OrderEnum.入库中.getValue());
        list.add(OrderEnum.完成.getValue());
        criteria.andIn("orderStatus", list);
        //上线时间
        if (0 == type) {
            criteria.andGreaterThan("createTime", time);
        } else if (1 == type) {
            criteria.andLessThan("createTime", time);
        }
        int i = orderMapper.selectCountByExample(example);
        return i;
    }

    public void add(OrderInfo orderInfo){
        orderMapper.insertSelective(orderInfo);
    }

    public List<OrderInfo> findByCreateUserIdAndNotNullTown(String userId){
        Example example = new Example(OrderInfo.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("createUserId", userId);
        criteria.andIsNotNull("townId");
        return orderMapper.selectByExample(example);
    }

    public OrderInfo findById(String id){
        return orderMapper.selectByPrimaryKey(id);
    }


    /**
     * 查询当前服务的数目
     * @param userId
     * @return
     */
    public int findFwzNum(String userId){
        Example example = new Example(OrderInfo.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("receiver", userId);
        List<String> list = new ArrayList<>();
        list.add(OrderEnum.服务中.getValue());
        list.add(OrderEnum.待接单.getValue());
        criteria.andIn("orderStatus", list);
        int i = orderMapper.selectCountByExample(example);
        return i;
    }

    /**
     * 查找当前用户所处服务中的位置
     * @param receiver
     * @param createUserId
     * @return
     */
    public int findListOrderReceiveTime(String receiver,String createUserId){
        List<OrderInfo> list = orderMapper.findListOrderReceiveTime(receiver);
        if(CollUtil.isEmpty(list)){
            return 0;
        }else {
            List<String> collect = list.stream().map(x -> x.getCreateUserId()).collect(Collectors.toList());
            if(StrUtil.isNotBlank(createUserId)) {
                int i = collect.indexOf(createUserId);
                i=i==-1?collect.size():i;
                return i;
            }else {
                return collect.size();
            }
        }
    }

    /**
     * 根据订单状态和回收员查询订单
     * @param userId
     * @param status
     * @return
     */
    public List<OrderInfo> findServiceOrderByUserIdAndStatus(String userId,List<String> status){
        return orderMapper.findServiceOrderByUserIdAndStatus(userId,status);
    }

    public List<OrderInfoVo> findLastTimeBycreateUserId(String userId){
        return  orderMapper.findLastTimeBycreateUserId(userId);
    }


    /**
     * 根据下单用户查找
     * @param createUserId
     * @param statusList
     * @return
     */
    public List<OrderInfo> findByCreateUserId(String createUserId, List<String> statusList){
        Example example = new Example(OrderInfo.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("createUserId", createUserId);
        if(CollUtil.isNotEmpty(statusList)) {
            criteria.andIn("orderStatus", statusList);
        }
        example.setOrderByClause("create_time desc");
        return orderMapper.selectByExample(example);
    }



}