package com.iamberry.rst.service.fm;


import com.auth0.jwt.internal.org.apache.commons.lang3.StringUtils;
import com.github.pagehelper.PageHelper;
import com.iamberry.redis.RedisUtils;
import com.iamberry.rst.core.cm.*;
import com.iamberry.rst.core.fm.*;
import com.iamberry.rst.core.order.Product;
import com.iamberry.rst.core.order.ProductColor;
import com.iamberry.rst.core.page.PageRequest;
import com.iamberry.rst.core.page.PagedResult;
import com.iamberry.rst.core.sys.Admin;
import com.iamberry.rst.core.tools.KuaiDi100;
import com.iamberry.rst.core.tools.LogisticsInfo;
import com.iamberry.rst.faces.cm.InventoryService;
import com.iamberry.rst.faces.fm.ComplaintSignclosedInfoService;
import com.iamberry.rst.faces.order.LogisticsInfoService;
import com.iamberry.rst.faces.sms.SmsService;
import com.iamberry.rst.service.cm.mapper.*;
import com.iamberry.rst.service.fm.mapper.*;
import com.iamberry.rst.service.product.mapper.ProductMapper;
import com.iamberry.rst.service.sys.mapper.SysMapper;
import com.iamberry.rst.util.PageUtil;
import com.iamberry.rst.util.ProduceNoUtil;
import com.iamberry.rst.util.SmsConfig;
import com.iamberry.wechat.tools.NameUtils;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
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.Isolation;
import org.springframework.transaction.annotation.Transactional;

import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class ComplaintSignclosedInfoServiceImpl implements ComplaintSignclosedInfoService {
    private Logger logger = LoggerFactory.getLogger(ComplaintSignclosedInfoServiceImpl.class);
    @Autowired
    private ComplaintSignclosedInfoMapper complaintSignclosedInfoMapper;
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private AwaitingSignclosedProductMapper awaitingSignclosedProductMapper;
    @Autowired
    private ComplaintSignclosedProductInfoMapper complaintSignclosedProductInfoMapper;
    @Autowired
    private ComplaintDetectInfoMapper complaintDetectInfoMapper;
    @Autowired
    private CustomerInfoMapper customerInfoMapper;
    @Autowired
    private InventoryMapper inventoryMapper;
    @Autowired
    private InventoryLogMapper inventoryLogMapper;
    @Autowired
    private SmsService smsService;

    @Autowired
    private InventoryService inventoryService;

    @Autowired
    private SysMapper sysMapper;

    @Autowired
    private SalesOrderMapper salesOrderMapper;
    @Autowired
    private KuaiDi100 kuaidi100;
    @Autowired
    private LogisticsInfoService logisticsInfoService;

    @Override
    @Transactional(rollbackFor = {Exception.class}, isolation = Isolation.REPEATABLE_READ)
    public Integer insert(ComplaintSignclosedInfo record, String orderItemString, String[] componentsImgs) {
        Integer msg = 0;
        int num = 0;
        Integer signclosedId = null;
        Integer flag = 0;
        List<ComplaintSignclosedInfo> sinfoList = new ArrayList<>();
        //查询是否已存在相同单号
        if(record.getSignclosedLogisticsNumber() != null){
            ComplaintSignclosedInfo info = new ComplaintSignclosedInfo();
            //判断是否是京东
            if (record.getSignclosedLogisticsNumber().contains("-")){
                //截取-前的内容搜索一次
                info.setSignclosedLogisticsNumber(StringUtils.substringBefore(record.getSignclosedLogisticsNumber(), "-"));
                sinfoList = complaintSignclosedInfoMapper.listSignclosed(info);
                if(sinfoList.size() <= 0){
                    //如果没有搜索到数据，则用完整单号搜索
                    info.setSignclosedLogisticsNumber(record.getSignclosedLogisticsNumber());
                    sinfoList = complaintSignclosedInfoMapper.listSignclosed(info);
                }
            }else{
                info.setSignclosedLogisticsNumber(record.getSignclosedLogisticsNumber());
                sinfoList = complaintSignclosedInfoMapper.listSignclosed(info);
            }
            if(sinfoList.size() <= 0){
                num = complaintSignclosedInfoMapper.insert(record);
                //添加成功
                msg = 1;
                signclosedId = record.getSignclosedId();
            }else{
                //将签收记录改为已签收
                ComplaintSignclosedInfo complaintSignclosedInfo = sinfoList.get(0);
                if(complaintSignclosedInfo.getSignclosedIsReceiving() == 1){
                    complaintSignclosedInfo.setSignclosedIsReceiving(2);
                    complaintSignclosedInfo.setSignclosedDate(new Date());
                    complaintSignclosedInfoMapper.updateSignclosedById(complaintSignclosedInfo);
                    //已存在相同单号的签收信息并修改状态为已签收
                    msg = 3;
                    signclosedId = complaintSignclosedInfo.getSignclosedId();
                }else{
                    //已存在相同单号的已签收信息
                    msg = 4;
                }

            }
        }
        if(num > 0){
            if(orderItemString != null){
                JSONArray jsonArray = JSONArray.fromObject(orderItemString);
                List<SalesOrderItem> salesOrderItemList = (List) JSONArray.toCollection(jsonArray, SalesOrderItem.class);
                    for (SalesOrderItem salesOrderItem:salesOrderItemList) {
                        if(salesOrderItem.getItemNum() > 0 && salesOrderItem.getItemColorId() > 0){
                        int i = 0;
                        SignclosedProductInfo signclosedProductInfo = new SignclosedProductInfo();
                        //根据颜色id获取产品信息获取产品信息
                        ProductColor productColor = productMapper.getProduceColor(salesOrderItem.getItemColorId());
                        if(productColor == null){
                            msg = 2;
                        }
                        if(salesOrderItem.getItemNum() != null && salesOrderItem.getItemNum() != 0){
                            signclosedProductInfo.setSignclosedId(record.getSignclosedId());
                            signclosedProductInfo.setProductName(productColor.getProductName());
                            signclosedProductInfo.setProductNum(salesOrderItem.getItemNum());
                            signclosedProductInfo.setSignclosedProductType(1);
                            signclosedProductInfo.setSignclosedProductId(productColor.getColorProductId());
                            signclosedProductInfo.setSignclosedProductColor(salesOrderItem.getItemColorId());
                            signclosedProductInfo.setSignclosedCreateTime(new Date());
                            signclosedProductInfo.setSignclosedState(2);
                            complaintSignclosedProductInfoMapper.insert(signclosedProductInfo);
                        }
                    }
                }
            }

            //添加签收图片
            if(componentsImgs != null) {
                if (componentsImgs.length > 0) {
                    for (String componentsImg : componentsImgs) {
                        ComplaintSignclosedImg complaintSignclosedImg = new ComplaintSignclosedImg();
                        complaintSignclosedImg.setImgUrl(componentsImg);
                        complaintSignclosedImg.setSignclosedId(record.getSignclosedId());
                        complaintSignclosedInfoMapper.insertImg(complaintSignclosedImg);
                    }
                }
            }
            //没有匹配上并且销售公司为‘优尼雅’，‘上朵’时不展示到待联系列表，并且生成维修信息，状态为‘待完善客户信息’
            if(sinfoList.size() <= 0){
                if(record.getSignclosedCompanyId() == 3 || record.getSignclosedCompanyId() == 4){
                    addDet(signclosedId,40);
                }
            }
            //关联客诉/判断是否关联客诉信息
            try {
                addDetect(record,2);
            }catch (Exception e){
                throw new RuntimeException("------------关联客诉出错------------");
            }
        }

        // 代签收 - >  已签收  需要入库到售后仓库
        if(msg==1 || msg == 3){
            List<SignclosedProductInfo> signclosedProductInfoList = complaintSignclosedProductInfoMapper.listSignclosedById(signclosedId);
            for (SignclosedProductInfo spi:signclosedProductInfoList) {
                //增加售后仓库的良品
                InventoryInfo inventoryInfo2 = new InventoryInfo();
                inventoryInfo2.setInventoryDefectiveProductNum(spi.getProductNum());
                inventoryInfo2.setInventoryProductBar(spi.getColorBar());
                inventoryInfo2.setWarehouseId(record.getWarehouseId());
                inventoryInfo2.setLogType(3);   //售后签收，都是次品
                inventoryInfo2.setInventoryRecentRecord("售后签收产品(签收ID:"+spi.getSignclosedId()+")");
                flag = inventoryService.addInventory(inventoryInfo2);
                if(flag < 1){
                    throw new RuntimeException("签收失败，更新库存失败。");
                }
            }
        }
        return msg;
    }

    /**
     * 关联客诉
     * @param record
     * type 1新增签收 2客服关联客诉
     * @return
     */
    @Override
    public int addDetect(ComplaintSignclosedInfo record,Integer type){
        CustomerInfo customerInfo = new CustomerInfo();
        List<CustomerInfo> listCustomer = new ArrayList<>();
        if(record.getSignclosedCustomerId() != null){
            customerInfo.setCustomerId(record.getSignclosedCustomerId());
            listCustomer = customerInfoMapper.listCustomer(customerInfo);
        }else if(record.getSignclosedLogisticsNumber() != null){
            //判断是否是京东
            if (record.getSignclosedLogisticsNumber().contains("-")){
                    //截取-前的内容搜索一次
                customerInfo.setSendLogisticsNo(StringUtils.substringBefore(record.getSignclosedLogisticsNumber(), "-"));
                listCustomer = customerInfoMapper.listCustomer(customerInfo);
                if(listCustomer.size() <= 0){
                    //如果没有搜索到数据，则用完整单号搜索
                    customerInfo.setSendLogisticsNo(record.getSignclosedLogisticsNumber());
                    listCustomer = customerInfoMapper.listCustomer(customerInfo);
                }
            }else{
                customerInfo.setSendLogisticsNo(record.getSignclosedLogisticsNumber());
                listCustomer = customerInfoMapper.listCustomer(customerInfo);
            }
        }
        ComplaintSignclosedInfo sigInfo = complaintSignclosedInfoMapper.getSignclosedById(record.getSignclosedId());
        boolean m = false;
        if(listCustomer.size() > 0){
            customerInfo = listCustomer.get(0);
            ComplaintSignclosedInfo signclosedInfo = new ComplaintSignclosedInfo();
            if(customerInfo.getSendbackInfoList().size()>0){
                for (SendbackInfo info : customerInfo.getSendbackInfoList()){
                    if(info.getSendbackLogisticsNo() != null){
                        if(info.getSendbackLogisticsNo().equals(sigInfo.getSignclosedLogisticsNumber())){
                            m = true;
                            //修改该寄回信息为已签收
                            info.setSendbackStatus(3);
                            customerInfoMapper.updateSendbackInfo(info);
                            //同步寄回id到签收信息
                            record.setSendbackId(info.getSendbackId());
                            complaintSignclosedInfoMapper.updateSignclosedById(record);
                        }
                    }
                }
            }
            SendbackInfo info = new SendbackInfo();
            if(!m || customerInfo.getSendbackInfoList().size() == 0){
                info.setSendbackStatus(3);
                info.setSendbackLogisticsCompany(sigInfo.getSignclosedLogistics());
                info.setSendbackLogisticsNo(sigInfo.getSignclosedLogisticsNumber());
                info.setSendbackName(sigInfo.getSignclosedSendName());
                info.setSendbackTel(sigInfo.getSignclosedSendTel());
                info.setRelationId(customerInfo.getRelationId());
                info.setSendbackSignTime(sigInfo.getSignclosedDate());
                List<SendbackItem> list = new ArrayList<>();
                if(customerInfoMapper.addSendbackInfo(info) > 0){
                    //添加寄回产品项
                    for(SignclosedProductInfo productInfo : sigInfo.getSignclosedProductInfoList()){
                        SendbackItem sendbackItem = new SendbackItem();
                        sendbackItem.setSendbackId(info.getSendbackId());
                        sendbackItem.setSendbackColorId(productInfo.getSignclosedProductColor());
                        sendbackItem.setSendbackProductId(productInfo.getSignclosedProductId());
                        sendbackItem.setSendbackProdcueNumber(productInfo.getProductNum());
                        list.add(sendbackItem);
                    }
                    customerInfoMapper.addSendbackItemList(list);
                }

            }
            //同步寄回id到签收信息
            signclosedInfo.setSendbackId(info.getSendbackId());
            signclosedInfo.setSignclosedCustomerId(customerInfo.getCustomerId());
            signclosedInfo.setSignclosedId(record.getSignclosedId());
            Integer msg = complaintSignclosedInfoMapper.updateSignclosedById(signclosedInfo);

        if(msg == 1){
            ComplaintSignclosedInfo infos = complaintSignclosedInfoMapper.getSignclosedById(record.getSignclosedId());
            //判断是否需要生成维修记录
            if(infos.getSignclosedProductInfoList().size() > 0) {
                for (SignclosedProductInfo productInfo : infos.getSignclosedProductInfoList()) {
                    ProductColor productColor = productMapper.getProduceColor(productInfo.getSignclosedProductColor());
                    Product product = productMapper.getProduce(productColor.getColorProductId());
                    if(product.getProductIsDetection() != null){
                        if (product.getProductIsDetection() == 1) {
                            for (int j = 0; j < productInfo.getProductNum(); j++) {
                                //添加待检测信息
                                //查询签收信息
                                ComplaintDetectInfo detectInfo = new ComplaintDetectInfo();
                                //生成维修编号
                                String number = detectNumber();
                                detectInfo.setDetectNumber(number);
                                detectInfo.setProductId(productColor.getColorProductId());
                                detectInfo.setProductColorId(productInfo.getSignclosedProductColor());
                                detectInfo.setDetectProductNumber(product.getProductNumber());
                                detectInfo.setDetectState(1);
                                detectInfo.setCustomerId(infos.getSignclosedCustomerId());
                                detectInfo.setIsMaintenance(0);
                                detectInfo.setDetectRenovation(0);
                                detectInfo.setDetectProcessingResults(0);
                                detectInfo.setSignclosedId(infos.getSignclosedId());
                                detectInfo.setDetectSource(1);
                                Calendar date = Calendar.getInstance();
                                date.setTime(new Date());
                                boolean fl = false;
                                for (int i = 1 ; i <= 3; i++){
                                    date.set(Calendar.DATE, date.get(Calendar.DATE) + i);
                                    //1--7的值,对应：星期日，星期一，星期二，星期三....星期六
                                    int week = date.get(Calendar.DAY_OF_WEEK);
                                    if(week == 1){
                                        fl = true;
                                    }
                                    date.set(Calendar.DATE, date.get(Calendar.DATE) - i);
                                }
                                if(fl){
                                    date.set(Calendar.DATE, date.get(Calendar.DATE) + 4);
                                }else{
                                    date.set(Calendar.DATE, date.get(Calendar.DATE) + 3);
                                }
                                detectInfo.setMaintenanceCutTime(date.getTime());
                                try {
                                    complaintDetectInfoMapper.insert(detectInfo);
                                    if(type == 1){
                                        //客服关联客诉才发送通知短信
                                        //发送短信通知维修检测人员
                                        // 仓库电话
                                        String tel = "18574702550";
                                        String text = MessageFormat.format(SmsConfig.CUSTOMER_CONTACT, sigInfo.getSignclosedLogisticsNumber(),number);
                                        String result = smsService.sendOtherCMS(tel, text);
                                        logger.info("给 " + tel + " 手机用户发送短信：" + text+"发送关联客诉通知维修人员："+result);
                                    }

                                } catch (Exception e) {
                                    throw new RuntimeException("------------生成检测信息出错------------");
                                }
                            }
                        }
                    }
                }
            }
        }
        }
        return 1;
    }
    /**
     * 根据签收id生成维修信息
     * @param signclosedId 签收id detectState 状态
     * @return
     */
    public void addDet(Integer signclosedId,Integer detectState){
        ComplaintSignclosedInfo sigInfo = complaintSignclosedInfoMapper.getSignclosedById(signclosedId);
        //判断是否需要生成维修记录
        if(sigInfo.getSignclosedProductInfoList().size() > 0) {
            for (SignclosedProductInfo productInfo : sigInfo.getSignclosedProductInfoList()) {
                ProductColor productColor = productMapper.getProduceColor(productInfo.getSignclosedProductColor());
                Product product = productMapper.getProduce(productColor.getColorProductId());
                if(product.getProductIsDetection() != null){
                    if (product.getProductIsDetection() == 1) {
                        for (int j = 0; j < productInfo.getProductNum(); j++) {
                            //添加待检测信息
                            //查询签收信息
                            ComplaintDetectInfo detectInfo = new ComplaintDetectInfo();
                            //生成维修编号
                            String number = detectNumber();
                            detectInfo.setDetectNumber(number);
                            detectInfo.setProductId(productColor.getColorProductId());
                            detectInfo.setProductColorId(productInfo.getSignclosedProductColor());
                            detectInfo.setDetectProductNumber(product.getProductNumber());
                            detectInfo.setDetectState(detectState);
                            detectInfo.setCustomerId(sigInfo.getSignclosedCustomerId());
                            detectInfo.setIsMaintenance(0);
                            detectInfo.setDetectRenovation(0);
                            detectInfo.setDetectProcessingResults(0);
                            detectInfo.setSignclosedId(sigInfo.getSignclosedId());
                            if(detectState != 40){
                                detectInfo.setDetectSource(1);
                                Calendar date = Calendar.getInstance();
                                date.setTime(new Date());
                                boolean fl = false;
                                for (int i = 1 ; i <= 3; i++){
                                    date.set(Calendar.DATE, date.get(Calendar.DATE) + i);
                                    int week = date.get(Calendar.DAY_OF_WEEK);//1--7的值,对应：星期日，星期一，星期二，星期三....星期六
                                    if(week == 1){
                                        fl = true;
                                    }
                                    date.set(Calendar.DATE, date.get(Calendar.DATE) - i);
                                }
                                if(fl){
                                    date.set(Calendar.DATE, date.get(Calendar.DATE) + 4);
                                }else{
                                    date.set(Calendar.DATE, date.get(Calendar.DATE) + 3);
                                }

                                detectInfo.setMaintenanceCutTime(date.getTime());
                            }else{
                                detectInfo.setDetectSource(2);
                            }
                            try {
                                complaintDetectInfoMapper.insert(detectInfo);
                            } catch (Exception e) {
                                throw new RuntimeException("------------生成检测信息出错------------");
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * 生成维修编号
     * @return
     */
    public String detectNumber(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
        String year = sdf.format(new Date());
        String detectNum = RedisUtils.get("detect_"+year);
        Integer detectNumber;
        if(detectNum == null){
            //查询当前月份所有维修机器
            Integer num = complaintDetectInfoMapper.getDetectNum();
            RedisUtils.put("detect_"+year,num);/*
            RedisUtils.expire(SC_DETECT+year,new Date(System.currentTimeMillis() + 2678400000L));*/
            detectNumber = num;
        }else{
            detectNumber =Integer.parseInt(detectNum)+ 1;
            RedisUtils.put("detect_"+year,detectNumber);
        }
        switch (detectNumber.toString().length()){
            case 1:
                detectNum = "000"+detectNumber;
                break;
            case 2:
                detectNum = "00"+detectNumber;
                break;
            case 3:
                detectNum = "0"+detectNumber;
                break;
            case 4:
                detectNum = detectNumber.toString();
                break;
        }
        return year+detectNum;
    }
    @Override
    public List<SignclosedProductInfo> listSignclosedById(Integer signclosedId) {
        return complaintSignclosedInfoMapper.listSignclosedById(signclosedId);
    }

    @Override
    public Integer insertImg(ComplaintSignclosedImg complaintSignclosedImg) {
        return complaintSignclosedInfoMapper.insertImg(complaintSignclosedImg);
    }

    @Override
    public List<ComplaintSignclosedImg> listSignclosedImgById(Integer signclosedId) {
        return complaintSignclosedInfoMapper.listSignclosedImgById(signclosedId);
    }

    @Override
    public Integer delSignclosedImg(Integer signclosedId) {
        return complaintSignclosedInfoMapper.delSignclosedImg(signclosedId);
    }

    @Override
    public Integer delSignclosedBySendbackId(Integer sendbackId) {
        return complaintSignclosedInfoMapper.delSignclosedBySendbackId(sendbackId);
    }

    @Override
    public Integer getSignclosedDay(ComplaintSignclosedInfo complaintSignclosedInfo) {
        return complaintSignclosedInfoMapper.getSignclosedDay(complaintSignclosedInfo);
    }

    @Override
    @Transactional
    public Integer updateSignclosedByYny(ComplaintSignclosedInfo record) {
        int num = complaintSignclosedInfoMapper.updateSignclosedById(record);
        if(num > 0){
            try {
                ComplaintSignclosedInfo signclosedInfo = complaintSignclosedInfoMapper.getSignclosedById(record.getSignclosedId());
                //新增维修记录
                if(signclosedInfo != null && signclosedInfo.getSignclosedProductInfoList().size() > 0){
                    for (SignclosedProductInfo productInfo : signclosedInfo.getSignclosedProductInfoList()){
                        Product product = productMapper.getProduce(productInfo.getSignclosedProductId());
                        if (product.getProductIsDetection() == 1) {
                            ComplaintDetectInfo  info = new ComplaintDetectInfo();
                            //生成维修编号
                            String number = detectNumber();
                            info.setDetectNumber(number);
                            info.setDetectState(40);
                            info.setDetectSource(2);
                            info.setProductId(productInfo.getSignclosedProductId());
                            info.setProductColorId(productInfo.getSignclosedProductColor());
                            info.setSignclosedId(record.getSignclosedId());
                            complaintDetectInfoMapper.insert(info);
                        }
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
                throw new RuntimeException("------------改为优尼雅客户生成检测信息出错------------");
            }

        }else{
            return num;
        }
        return 1;
    }

    @Override
    public List<SignclosedProductInfo> listSignclosedProductById(Integer customerId) {
        return complaintSignclosedInfoMapper.listSignclosedProductById(customerId);
    }

    @Transactional
    @Override
    public Integer delSignclosedById(Integer signclosedId) {
        List<SignclosedProductInfo> signclosedProductInfoList = complaintSignclosedInfoMapper.listSignclosedById(signclosedId);
        for (SignclosedProductInfo spi:signclosedProductInfoList) {
            //增加售后仓库的良品
            InventoryInfo inventoryInfo2 = new InventoryInfo();
            inventoryInfo2.setInventoryProductColorId(spi.getSignclosedProductColor());
            inventoryInfo2.setInventoryDefectiveProductNum(spi.getProductNum());
            inventoryInfo2.setInventoryProductBar(spi.getColorBar());
            inventoryInfo2.setWarehouseId(2);
            inventoryInfo2.setLogType(3);   //售后签收，都是次品
            inventoryInfo2.setInventoryRecentRecord("售后删除签收产品(签收ID:"+spi.getSignclosedId()+")");
            int flag = inventoryService.minusInventory(inventoryInfo2);
            if(flag < 1){
                throw new RuntimeException("删除签收失败，更新库存失败。");
            }
        }
        return complaintSignclosedInfoMapper.delSignclosedById(signclosedId);
    }

    @Override
    public Integer getCompleteSent(ComplaintSignclosedInfo complaintSignclosedInfo) {
        return complaintSignclosedInfoMapper.getCompleteSent(complaintSignclosedInfo);
    }

//    private Integer addSifnclosed(Map<String,Integer> Map,Integer signclosedId) {
//        Integer msg = 0;
//        for (Map.Entry<String, Integer> entry : Map.entrySet()) {
//            AwaitingSignclosedProductInfo awaitingSignclosedInfo = new AwaitingSignclosedProductInfo();
//            //根据颜色id获取产品信息获取产品信息
//            Product product = productMapper.getProductById(Integer.valueOf(entry.getKey()));
//            if (product == null) {
//                return 0;
//            }
//            awaitingSignclosedInfo.setSignclosedId(signclosedId);
//            awaitingSignclosedInfo.setProductName(product.getProductName());
//            awaitingSignclosedInfo.setProductNum(entry.getValue());
//            awaitingSignclosedInfo.setSignclosedProductType(1);
//            awaitingSignclosedInfo.setSignclosedProductId(product.getProductId());
//            awaitingSignclosedInfo.setSignclosedProductColor(Integer.valueOf(entry.getKey()));
//            awaitingSignclosedInfo.setSignclosedCreateTime(new Date());
//            msg = awaitingSignclosedProductMapper.insert(awaitingSignclosedInfo);
//
//        }
//        return msg;
//    }

    @Override
    public ComplaintSignclosedInfo getSignclosedById(Integer signclosedId) {
        return complaintSignclosedInfoMapper.getSignclosedById(signclosedId);
    }
    @Transactional
    @Override
    public boolean updateSignclosedById(ComplaintSignclosedInfo record,
                                    Map<String,Integer> alreadyColorMap,
                                    Map<String,String[]> machineNumberMap,
                                    Map<String,Integer> alreadyFittingsMap) {
        boolean msg = true;
        int num = complaintSignclosedInfoMapper.updateSignclosedById(record);
        if(num < 1){
            msg = false;
        }else{
            if(alreadyColorMap != null || alreadyColorMap.size() != 0){
                for (Map.Entry<String,Integer> entry : alreadyColorMap.entrySet()) {
                    int i = 0;
                    SignclosedProductInfo signclosedProductInfo = new SignclosedProductInfo();
                    //根据颜色id获取产品信息获取产品信息
                    Product product = productMapper.getProductById(Integer.valueOf(entry.getKey()));
                    if(product == null){
                        return false;
                    }
                    for (int j = 0;j<entry.getValue();j++){
                        signclosedProductInfo.setSignclosedId(record.getSignclosedId());
                        signclosedProductInfo.setProductName(product.getProductName());
                        signclosedProductInfo.setProductNum(1);
                        signclosedProductInfo.setSignclosedProductType(1);
                        signclosedProductInfo.setSignclosedProductId(product.getProductId());
                        signclosedProductInfo.setSignclosedProductColor(Integer.valueOf(entry.getKey()));
                        signclosedProductInfo.setSignclosedCreateTime(new Date());
                        complaintSignclosedProductInfoMapper.insert(signclosedProductInfo);
                        i++;
                    }

                }
            }
        }
        return msg;
    }
    @Transactional
    @Override
    public boolean updateSignclosedById(ComplaintSignclosedInfo record, String orderItemString, String[] componentsImgs) {
        boolean msg = true;
        int num = complaintSignclosedInfoMapper.updateSignclosedById(record);
        if(num < 1){
            msg = false;
        }else{
            //删除待收货产品
            complaintSignclosedProductInfoMapper.delSignclosedProduct(record.getSignclosedId());
            //删除签收图片
            complaintSignclosedInfoMapper.delSignclosedImg(record.getSignclosedId());
            //拼接产品名称
            StringBuffer puoductbuffer = new StringBuffer("");
            if(orderItemString != null){
                JSONArray jsonArray = JSONArray.fromObject(orderItemString);
                List<SalesOrderItem> salesOrderItemList = (List) JSONArray.toCollection(jsonArray, SalesOrderItem.class);
                for (SalesOrderItem salesOrderItem:salesOrderItemList) {
                    if(salesOrderItem.getItemNum() > 0 && salesOrderItem.getItemColorId() > 0){
                        int i = 0;
                        SignclosedProductInfo signclosedProductInfo = new SignclosedProductInfo();
                        //根据颜色id获取产品信息获取产品信息
                        ProductColor productColor = productMapper.getProduceColor(salesOrderItem.getItemColorId());
                        Product product = productMapper.getProduce(productColor.getColorProductId());
                        if(productColor == null){
                            msg = false;
                        }
                        signclosedProductInfo.setSignclosedId(record.getSignclosedId());
                        signclosedProductInfo.setProductName(productColor.getProductName());
                        signclosedProductInfo.setProductNum(1);
                        signclosedProductInfo.setSignclosedProductType(1);
                        signclosedProductInfo.setSignclosedProductId(productColor.getColorProductId());
                        signclosedProductInfo.setSignclosedProductColor(salesOrderItem.getItemColorId());
                        signclosedProductInfo.setSignclosedCreateTime(new Date());
                        signclosedProductInfo.setSignclosedState(2);
                        try {
                            complaintSignclosedProductInfoMapper.insert(signclosedProductInfo);
                        }catch (Exception e){
                            throw new RuntimeException("------------生成签收产品出错------------");
                        }
                        puoductbuffer.append(productColor.getProductName() + "("+productColor.getColorName()+")*1");
                    }
                }
            }
            //添加签收图片
            if(componentsImgs != null){
                if(componentsImgs.length > 0){
                    for(String componentsImg : componentsImgs){
                        ComplaintSignclosedImg complaintSignclosedImg = new ComplaintSignclosedImg();
                        complaintSignclosedImg.setImgUrl(componentsImg);
                        complaintSignclosedImg.setSignclosedId(record.getSignclosedId());
                        complaintSignclosedInfoMapper.insertImg(complaintSignclosedImg);
                    }
                }
            }

            //同步客诉寄回状态和物流信息
            ComplaintSignclosedInfo signclosedInfo = complaintSignclosedInfoMapper.getSignclosedById(record.getSignclosedId());
            //调快递查询接口获取签收时间
            LogisticsInfo log = new LogisticsInfo();
            log.setLogisticsRstCode(signclosedInfo.getSignclosedLogistics());
            List<LogisticsInfo> listlog = logisticsInfoService.getLogisticsInfoList(log);
            /*Date signTime = kuaidi100.selectCourierSignTime(listlog.get(0),signclosedInfo.getSignclosedLogisticsNumber());*/
            SendbackInfo sendbackInfo = new SendbackInfo();
            sendbackInfo.setSendbackId(signclosedInfo.getSendbackId());
            sendbackInfo.setSendbackStatus(3);
            sendbackInfo.setSendbackLogisticsCompany(signclosedInfo.getSignclosedLogistics());
            sendbackInfo.setSendbackLogisticsNo(signclosedInfo.getSignclosedLogisticsNumber());
            /*if (signTime != null) {
                sendbackInfo.setSendbackSignTime(signTime);
            }else{
                sendbackInfo.setSendbackSignTime(new Date());
            }*/
            sendbackInfo.setSendbackSignTime(new Date());
            if(record.getSendbackIsUse() != null){
                sendbackInfo.setSendbackIsUse(record.getSendbackIsUse());
                if(record.getSendbackIsUse() == 1){
                    puoductbuffer.append(",状态：未使用");
                }else if(record.getSendbackIsUse() == 2){
                    puoductbuffer.append(",状态：已使用");
                }

            }
            if(record.getSignclosedDesc() != null && !record.getSignclosedDesc().equals("")){
                puoductbuffer.append(",备注："+record.getSignclosedDesc());
            }
            customerInfoMapper.updateSendbackInfo(sendbackInfo);

            SendbackInfo sendback =  customerInfoMapper.getSendbackInfo(signclosedInfo.getSendbackId());
            if(sendback.getSendbackNoticeCustomer()!= null && sendback.getSendbackNoticeCustomer() == 1){
                Admin admin = new Admin();
                admin.setAdminId(sendback.getSendbackPresaleAdminId());
                admin = sysMapper.getAdminInfo(admin);
                String con = SmsConfig.SIGNCLOSED_NOTICE_CUSTOMERN;
                List<SalesOrder> listSalesOrder = salesOrderMapper.listSalesOrderbyCustomerId(signclosedInfo.getSignclosedCustomerId());
                String text = MessageFormat.format(con, listSalesOrder.get(0).getSalesOrderId(),signclosedInfo.getSignclosedLogisticsNumber(),puoductbuffer);
                smsService.sendOtherCMS(admin.getAdminTel(), text);
            }

            Integer flag = 0;
            // 代签收 - >  已签收  需要入库到售后仓库
            List<SignclosedProductInfo> signclosedProductInfoList = complaintSignclosedProductInfoMapper.listSignclosedById(record.getSignclosedId());
            for (SignclosedProductInfo spi:signclosedProductInfoList) {
                //增加售后仓库的良品
                InventoryInfo inventoryInfo2 = new InventoryInfo();
                inventoryInfo2.setInventoryDefectiveProductNum(spi.getProductNum());
                inventoryInfo2.setInventoryProductBar(spi.getColorBar());
                inventoryInfo2.setWarehouseId(record.getWarehouseId());
                //售后签收，都是次品
                inventoryInfo2.setLogType(3);
                inventoryInfo2.setInventoryRecentRecord("售后签收产品(签收ID:"+spi.getSignclosedId()+")");
                flag = inventoryService.addInventory(inventoryInfo2);
                if(flag < 1){
                    throw new RuntimeException("签收失败，更新库存失败。");
                }
            }
        }
        //关联客诉/判断是否生成客诉信息
        try {
            addDet(record.getSignclosedId(),1);
        }catch (Exception e){
            throw new RuntimeException("------------关联客诉出错------------");
        }

        return msg;
    }

    @Override
    public Integer updateSignclosedById(ComplaintSignclosedInfo record) {
        return complaintSignclosedInfoMapper.updateSignclosedById(record);
    }

    @Override
    public Integer updateSignclosedByCustomerId(ComplaintSignclosedInfo record) {
        return complaintSignclosedInfoMapper.updateSignclosedByCustomerId(record);
    }

    @Override
    public PagedResult<ComplaintSignclosedInfo> listSignclosed(PageRequest<ComplaintSignclosedInfo> pageRequest) {
        if (pageRequest.getData() == null) {
            pageRequest.setData(new ComplaintSignclosedInfo());
        }
        // 计算起始数据
        pageRequest.getData().setOffset((pageRequest.getPageNO()-1)*pageRequest.getPageSize());
        pageRequest.getData().setPageNum(pageRequest.getPageSize());
        // 执行查询
        List<ComplaintSignclosedInfo> signclosedList = complaintSignclosedInfoMapper.listSignclosed(pageRequest.getData());
        // 查询分页数据
        int total = complaintSignclosedInfoMapper.countSigncoled(pageRequest.getData());
        // 返回指定数据
        PagedResult<ComplaintSignclosedInfo> result = new PagedResult<ComplaintSignclosedInfo>();
        result.setPageNo(pageRequest.getPageNO());
        result.setPageSize(pageRequest.getPageSize());
        result.setDataList(signclosedList);
        int temp = total/pageRequest.getPageSize();
        result.setTotal(total == 0 ? 0 : (total%pageRequest.getPageSize()==0?temp:temp+1));
        return result;

    }

    @Override
    public List<ComplaintSignclosedInfo> listSignclosed(ComplaintSignclosedInfo complaintSignclosedInfo) {
        return complaintSignclosedInfoMapper.listSignclosed(complaintSignclosedInfo);
    }

}