package com.xzx.gc.order.service;

import cn.hutool.core.codec.Base64;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.StrUtil;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.xzx.gc.common.constant.Constants;
import com.xzx.gc.common.constant.OrderEnum;
import com.xzx.gc.common.constant.SysConfigConstant;
import com.xzx.gc.common.utils.BusinessSimpleUtil;
import com.xzx.gc.common.utils.BusinessUtil;
import com.xzx.gc.common.utils.StringUtils;
import com.xzx.gc.entity.ConfigInfo;
import com.xzx.gc.entity.OrderAppraiseInfo;
import com.xzx.gc.entity.OrderInfo;
import com.xzx.gc.entity.ResourceInfo;
import com.xzx.gc.model.admin.AppraiseInfoTotalModel;
import com.xzx.gc.model.admin.XzxOrderAppraiseInfoModel;
import com.xzx.gc.model.order.QueryReceiverTotalListDTO;
import com.xzx.gc.model.order.QueryReceiverTotalListResDTO;
import com.xzx.gc.order.mapper.ConfigMapper;
import com.xzx.gc.order.mapper.OrderAppraiseInfoMapper;
import com.xzx.gc.order.mapper.OrderMapper;
import com.xzx.gc.order.mapper.ResourceInfoMapper;
import com.xzx.gc.util.DateUtil;
import com.xzx.gc.util.DoubleUtil;
import com.xzx.gc.util.enums.EvaluationLabelType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestBody;
import tk.mybatis.mapper.entity.Example;
import tk.mybatis.mapper.util.StringUtil;

import javax.servlet.http.HttpServletRequest;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@Transactional
public class OrderAppraiseInfoService {

    @Autowired
    private OrderAppraiseInfoMapper orderAppraiseInfoMapper;

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private ResourceInfoMapper resourceInfoMapper;

    @Autowired
    private ConfigMapper configMapper;

    @Autowired
    private CityPartnerService cityPartnerService;

    @Autowired
    private HttpServletRequest request;

    @Autowired
    private BusinessUtil businessUtil;

    @Autowired
    private ConfigService configService;


    /**
     * 根据订单查询评价 目前仅支持1次评价
     * @param orderId
     * @return
     */
    public OrderAppraiseInfo findByOrderId(String orderId){
        OrderAppraiseInfo orderAppraiseInfo = new OrderAppraiseInfo();
        orderAppraiseInfo.setOrderId(orderId);
        orderAppraiseInfo.setDelFlag(Convert.toShort(Constants.DEL_NOT_FLAG));
        List<OrderAppraiseInfo> orderAppraiseInfo1 = orderAppraiseInfoMapper.select(orderAppraiseInfo);
        if(CollUtil.isNotEmpty(orderAppraiseInfo1)){
            return orderAppraiseInfo1.get(0);
        }
        return null;
    }

    public OrderAppraiseInfo findById(Long id){
        OrderAppraiseInfo orderAppraiseInfo = orderAppraiseInfoMapper.selectByPrimaryKey(id);
        if(orderAppraiseInfo!=null){
            orderAppraiseInfo.setContent(encodeOrDecode(orderAppraiseInfo.getContent(), 1));
        }
        return orderAppraiseInfo;
    }

    /**
     * 查询回收员的评价
     * @param receiver
     * @return
     */
    public List<OrderAppraiseInfo> findByReceiver(String receiver){
        Example example=new Example(OrderAppraiseInfo.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("delFlag",Convert.toShort(Constants.DEL_NOT_FLAG));
        criteria.andEqualTo("receiverId",receiver);
        example.setOrderByClause("create_time desc");
        return orderAppraiseInfoMapper.selectByExample(example);
    }

    /**
     * 查询综合评分、完成订单数 总共被评价数
     * @param receiver 回收员ID
     * @return
     */
    public OrderAppraiseInfo findStarInfo(String receiver,String createUserId){
        OrderAppraiseInfo orderAppraiseInfo = new OrderAppraiseInfo();
        orderAppraiseInfo.setDelFlag(Convert.toShort(Constants.DEL_NOT_FLAG));
        orderAppraiseInfo.setReceiverId(receiver);
        List<OrderAppraiseInfo> select = findByReceiver(receiver);
        if (CollUtil.isNotEmpty(select)) {
            Double sum = select.stream().mapToDouble(x -> Convert.toDouble(x.getStar())).sum();
            double div = NumberUtil.div(sum, Convert.toDouble(select.size()));
            orderAppraiseInfo.setNum(select.size());
            String s = NumberUtil.roundStr(div, 1, RoundingMode.DOWN);
            orderAppraiseInfo.setStar(s);
        } else {
            orderAppraiseInfo.setStar("0.0");
            orderAppraiseInfo.setNum(0);
        }

        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());
        list.add(OrderEnum.完成.getValue());
        criteria.andIn("orderStatus", list);
        int i = orderMapper.selectCountByExample(example);
        orderAppraiseInfo.setCompleteOrderNum(i);
        //预计时间 服务中多一个用户多1小时
        int fwzNum;
        List<OrderInfo> listReceive = orderMapper.findListOrderReceiveTime(receiver);
        if(CollUtil.isEmpty(listReceive)){
            fwzNum= 0;
        }else {
            List<String> collect = listReceive.stream().map(x -> x.getCreateUserId()).collect(Collectors.toList());
            if(StrUtil.isNotBlank(createUserId)) {
                fwzNum= collect.indexOf(createUserId);
                fwzNum=fwzNum==-1?collect.size():fwzNum;
            }else {
                fwzNum= collect.size();
            }
        }
        orderAppraiseInfo.setQueueNum(fwzNum);
        return orderAppraiseInfo;
    }


    /**
     * 处理资源和标签信息
     * @param orderAppraiseInfo1
     * @return
     */
    public void changeResouceAndTag(OrderAppraiseInfo orderAppraiseInfo1){
        String resourceIds = orderAppraiseInfo1.getResourceIds();

        List<ResourceInfo> resourceList=new ArrayList<>();

        List<String> tagValues=new ArrayList<>();


        if(StrUtil.isNotBlank(resourceIds)){
            for (String id:resourceIds.split(",")) {
                ResourceInfo resourceInfo = resourceInfoMapper.selectByPrimaryKey(id);
                resourceList.add(resourceInfo);
            }
            orderAppraiseInfo1.setResourceList(resourceList);
        }
        String tagCodes = orderAppraiseInfo1.getTagCodes();

        if(StrUtil.isNotBlank(tagCodes)){
            for (String id:tagCodes.split(",")) {
                ConfigInfo configInfo=new ConfigInfo();
                configInfo.setConfigTypeCode(id);
                ConfigInfo configInfo1 = configMapper.selectOne(configInfo);
                if(configInfo1!=null){
                    tagValues.add(configInfo1.getConfigValue());
                    String configTypeName = configInfo1.getConfigTypeName();
                    orderAppraiseInfo1.setTagSummary(configTypeName);

                }
            }
            orderAppraiseInfo1.setTagValues(tagValues);
        }
    }




    public Map<String,Object> queryAppraiseInfolist(@RequestBody XzxOrderAppraiseInfoModel model){
        List<String> partnerIds = cityPartnerService.queryPartnerByCurrent();
        model.setPartnerIds(partnerIds);
        Map<String,Object> map = new HashMap<>();
        PageHelper.startPage(model.getPage(),model.getLimit());
        List<XzxOrderAppraiseInfoModel> list = orderAppraiseInfoMapper.queryAppraiseInfoList(model);
        for(XzxOrderAppraiseInfoModel infoModel:list) {
            String nickName = infoModel.getUserName();
            if(nickName!=null&&!"".equals(nickName)){
                nickName =Base64.decodeStr(nickName);

            }


            infoModel.setUserName(nickName);
            infoModel.setRelaName(infoModel.getUserName());
            infoModel.setMobilePhone(infoModel.getUserPhone());
            infoModel.setName(infoModel.getReceiverName());

            String value ="tagAppraise"+infoModel.getStar();
            infoModel.setStarDesc(orderAppraiseInfoMapper.queryConfigByAppraseInfo(value));
            String tag = infoModel.getTagCodes();
            if(null!=tag&&!"".equals(tag)){
                String[] strs = tag.split(",");
                List<String> codes = new ArrayList<>();
                for (String str:strs) {
                    codes.add(str);
                }
                List<String> tagValues = orderAppraiseInfoMapper.queryConfigByTagCode(codes);
                //拼接服务打标
                StringBuffer buf = new StringBuffer();
                for (int i=0;i<tagValues.size();i++) {
                    if(i==0){
                        buf.append(tagValues.get(i)) ;
                    }else{
                        buf.append("、").append(tagValues.get(i));
                    }
                }
                infoModel.setTagDesc(buf.toString());
            }else{
                infoModel.setTagCodes("-");
                infoModel.setTagDesc("-");
            }
            //拼接图片
            List<String> urls = new ArrayList<>();
            String resourceIds = infoModel.getResourceIds();
            if(null!=resourceIds&&!"".equals(resourceIds)){
                String[] resIds = resourceIds.split(",");
                List<String> resArr = new ArrayList<>();
                for (String res:resIds) {
                    resArr.add(res);
                }
                if(resArr.size()>0){
                     urls = orderAppraiseInfoMapper.queryResourceUrls(resArr);
                    infoModel.setImgUrls(urls);
                }

            }
            if(null!=infoModel.getContent()&&!"".equals(infoModel.getContent())){
                    if(StringUtils.isBase64(infoModel.getContent())){
                        infoModel.setContent(Base64.decodeStr(infoModel.getContent()));
                    }

            }else{
                infoModel.setContent("-");

            }

        }

        PageInfo<XzxOrderAppraiseInfoModel> pageInfo=new PageInfo<>(list);
        map.put("data",list);
        map.put("code",0);
        map.put("count",pageInfo.getTotal());
        return map;
    }

    public Map<String,Object> queryReceiverTotalList(XzxOrderAppraiseInfoModel model){
        String partnerId = model.getPartnerId();
        String name = model.getName();
        String receiverId = model.getReceiverId();

        List<String> partnerIds = new ArrayList<>();

        if(businessUtil.isWeb(request.getHeader("clientType"))){
            if(null!=partnerId&&!"".equals(partnerId)){
                partnerIds.add(partnerId);
            }else{
                partnerIds = cityPartnerService.queryPartnerByCurrent();
            }
        }

        PageHelper.startPage(model.getPage(),model.getLimit());
        List<Map<String,Object>> list = orderAppraiseInfoMapper.queryReceiverTotalList(name,partnerIds,receiverId);
        PageInfo<Map<String,Object>> pageInfo=new PageInfo<>(list);

        for (Map<String,Object> map:list) {
            String star = DoubleUtil.roundOne(map.get("star").toString());
            map.put("star",star);
        }
        Map<String,Object> map = new HashMap<>();
        map.put("code",0);
        map.put("data",list);
        map.put("count",pageInfo.getTotal());
        return map;
    }

    public AppraiseInfoTotalModel queryAppraiseInfoTotalList(AppraiseInfoTotalModel paramModel){
        List<String> partnerIds=new ArrayList<>();
        if(businessUtil.isWeb(request.getHeader("clientType"))) {
            partnerIds = cityPartnerService.queryPartnerByCurrent();
        }
        AppraiseInfoTotalModel model = new AppraiseInfoTotalModel();
        model.setBehaveBadlyNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.ONE_TYPE));
        model.setSeriousTardinessNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.TWO_TYPE));
        model.setLowProcessingEfficiencyNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.THREE_TYPE));
        model.setPoorServiceAwarenessNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.FOUR_TYPE));
        model.setBadAttitudeNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.FIVE_TYPE));
        model.setLateArrivalNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.SIX_TYPE));
        model.setLowProcessingNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.SENVEN_TYPE));
        model.setLowServiceNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.EIGHT_TYPE));
        model.setSoAttitudeNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.NINE_TYPE));
        model.setNoLateNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.TEN_TYPE));
        model.setProcessingNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.ELE_TYPE));
        model.setServiceAwarenessNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.TELF_TYPE));
        model.setGoodAttitudeNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.THR_TYPE));
        model.setOnTimeNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.FOR_TYPE));
        model.setGoodProcessingNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.FIV_TYPE));
        model.setGoodServiceAwarenessNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.SI_TYPE));
        model.setGoodPaySatisfiedNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.SEV_TYPE));
        model.setGoodServiceSatisfiedNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.EIG_TYPE));
        model.setGreatRecyclerNumDesc(orderAppraiseInfoMapper.queryConfigByTagCodeOne(EvaluationLabelType.NIG_TYPE));
        //保存星级个数汇总
        List<Map<String,Object>> starList = orderAppraiseInfoMapper.queryStarTotalNum(partnerIds,paramModel.getReceiverId());
        for (Map<String,Object> obj:starList) {
            String star = obj.get("star").toString();
            String starNum = obj.get("num").toString();
            if(star.equals("1")){
                model.setOneStarNum(starNum);
            }else if(star.equals("2")){
                model.setTwoStarNum(starNum);
            }else if(star.equals("3")){
                model.setThreeStarNum(starNum);
            }else if(star.equals("4")){
                model.setFourStarNum(starNum);
            }else if(star.equals("5")){
                model.setFiveStarNum(starNum);
            }
            List<String> codesList = getModelCodeList(star);
            if(codesList.size()>0){
                for (String codesl:codesList) {
                    String[] codesStrs = codesl.split(",");
                    for (String codes:codesStrs) {
                        getConfigNum(model,codes);

                    }
                }

            }

        }
        return model;
    }

    private List<String> getModelCodeList(String star){
        return orderAppraiseInfoMapper.getModelCodeList(star);
    }

    private AppraiseInfoTotalModel getConfigNum(AppraiseInfoTotalModel model, String configTypeCode){

        //无法直接使用switch case，因为是String类型
        switch (DateUtil.getCaseByType(configTypeCode)) {
            case 1:model.setBehaveBadlyNum((Integer.parseInt(model.getBehaveBadlyNum())+1)+""); break;
            case 2:model.setSeriousTardinessNum((Integer.parseInt(model.getSeriousTardinessNum())+1)+""); break;
            case 3:model.setLowProcessingEfficiencyNum((Integer.parseInt(model.getLowProcessingEfficiencyNum())+1)+""); break;
            case 4:model.setPoorServiceAwarenessNum((Integer.parseInt(model.getPoorServiceAwarenessNum())+1)+""); break;
            case 5:model.setBadAttitudeNum((Integer.parseInt(model.getBadAttitudeNum())+1)+""); break;
            case 6:model.setLateArrivalNum((Integer.parseInt(model.getLateArrivalNum())+1)+""); break;
            case 7:model.setLowProcessingNum((Integer.parseInt(model.getLowProcessingNum())+1)+""); break;
            case 8:model.setLowServiceNum((Integer.parseInt(model.getLowServiceNum())+1)+""); break;
            case 9:model.setSoAttitudeNum((Integer.parseInt(model.getSoAttitudeNum())+1)+""); break;
            case 10:model.setNoLateNum((Integer.parseInt(model.getNoLateNum())+1)+""); break;
            case 11:model.setProcessingNum((Integer.parseInt(model.getProcessingNum())+1)+""); break;
            case 12:model.setServiceAwarenessNum((Integer.parseInt(model.getServiceAwarenessNum())+1)+""); break;
            case 13:model.setGoodAttitudeNum((Integer.parseInt(model.getGoodAttitudeNum())+1)+""); break;
            case 14:model.setOnTimeNum((Integer.parseInt(model.getOnTimeNum())+1)+""); break;
            case 15:model.setGoodProcessingNum((Integer.parseInt(model.getGoodProcessingNum())+1)+""); break;
            case 16:model.setGoodServiceAwarenessNum((Integer.parseInt(model.getGoodServiceAwarenessNum())+1)+""); break;
            case 17:model.setGoodPaySatisfiedNum((Integer.parseInt(model.getGoodPaySatisfiedNum())+1)+""); break;
            case 18:model.setGoodServiceSatisfiedNum((Integer.parseInt(model.getGoodServiceSatisfiedNum())+1)+""); break;
            case 19:model.setGreatRecyclerNum((Integer.parseInt(model.getGreatRecyclerNum())+1)+""); break;
            default:
                break;
        }
        return model;
    }

    /**
     * 添加评价
     * @param orderAppraiseInfo
     */
    public void add(OrderAppraiseInfo orderAppraiseInfo){
        orderAppraiseInfo.setCreateTime(cn.hutool.core.date.DateUtil.now());
        orderAppraiseInfo.setDelFlag(Convert.toShort(Constants.DEL_NOT_FLAG));
        orderAppraiseInfo.setContent(encodeOrDecode(orderAppraiseInfo.getContent(), 0));
        orderAppraiseInfoMapper.insertSelective(orderAppraiseInfo);
    }


    /**
     * 进行编码或解码
     * @param type 0 :编码 1解码
     */
    public String encodeOrDecode(String content,int type){

        if(type==0){
            //编码
            if(StrUtil.isNotBlank(content)){
                return Base64.encode(content);
            }
        }else if(type==1){
            //解码
            if(StrUtil.isNotBlank(content)&&StringUtils.isBase64(content)){
                return Base64.decodeStr(content);
            }
        }
        return content;
    }

    public List<QueryReceiverTotalListResDTO> findTagByReceive(QueryReceiverTotalListDTO queryReceiverTotalListDTO) {
        String receiverId = queryReceiverTotalListDTO.getReceiverId();
        List<QueryReceiverTotalListResDTO> resList=new ArrayList<>();
        List<QueryReceiverTotalListResDTO> list=new ArrayList<>();
        List<OrderAppraiseInfo> byReceiver = findByReceiver(receiverId);

        List<ConfigInfo> tag1 = configService.findByGroup(SysConfigConstant.TAGAPPRAISE1);
        List<ConfigInfo> tag2 =configService.findByGroup(SysConfigConstant.TAGAPPRAISE2);
        List<ConfigInfo> tag3 =configService.findByGroup(SysConfigConstant.TAGAPPRAISE3);
        List<ConfigInfo> tag4 =configService.findByGroup(SysConfigConstant.TAGAPPRAISE4);
        List<ConfigInfo> tag5 = configService.findByGroup(SysConfigConstant.TAGAPPRAISE5);

        aggreation(list,tag5,false);
        aggreation(list,tag4,false);
        aggreation(list,tag3,false);
        aggreation(list,tag2,true);
        aggreation(list,tag1,true);

        if(CollUtil.isEmpty(byReceiver)){
            return CollUtil.sub(list,0,8);
        }else {
            for (OrderAppraiseInfo orderAppraiseInfo : byReceiver) {
                String tagCodes = orderAppraiseInfo.getTagCodes();
                if (StrUtil.isNotBlank(tagCodes)) {
                    String[] split = tagCodes.split(",");
                    for (String s : split) {
                        //出现当前标签的次数
                        List<QueryReceiverTotalListResDTO> forList = resList.stream().filter(x -> x.getConfigTypeCode().equals(s)).collect(Collectors.toList());
                        QueryReceiverTotalListResDTO config = list.stream().filter(x -> x.getConfigTypeCode().equals(s)).collect(Collectors.toList()).get(0);
                        if (CollUtil.isEmpty(forList)) {
                            config.setTagNum(1);
                            resList.add(config);
                        } else {
                            int num = forList.get(0).getTagNum();
                            forList.get(0).setTagNum(++num);
                        }
                    }
                }
            }
            return resList;
        }


    }

    private void aggreation(List<QueryReceiverTotalListResDTO> list,List<ConfigInfo> tag,boolean negativeCommentFlag){
        for (ConfigInfo configInfo : tag) {
            QueryReceiverTotalListResDTO dto=new QueryReceiverTotalListResDTO();
            dto.setConfigTypeCode(configInfo.getConfigTypeCode());
            dto.setTagName(configInfo.getConfigValue());
            dto.setNegativeCommentFlag(negativeCommentFlag);
            list.add(dto);
        }
    }
}