package com.yuanchu.mom.service.impl;

import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yuanchu.mom.Task.SyncOrder;
import com.yuanchu.mom.mapper.SaleMaterialMapper;
import com.yuanchu.mom.pojo.Sale;
import com.yuanchu.mom.mapper.SaleMapper;
import com.yuanchu.mom.pojo.SaleMaterial;
import com.yuanchu.mom.pojo.dto.ConsignmentDto1;
import com.yuanchu.mom.pojo.dto.ConsignmentDto2;
import com.yuanchu.mom.pojo.dto.SaleDto;
import com.yuanchu.mom.pojo.dto.SaleMaterialDto;
import com.yuanchu.mom.pojo.vo.SaleVo;
import com.yuanchu.mom.service.SaleMaterialService;
import com.yuanchu.mom.service.SaleService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yuanchu.mom.vo.Result;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 销售单 服务实现类
 * </p>
 *
 * @author 江苏鵷雏网络科技有限公司
 * @since 2023-08-08
 */
@Service
public class SaleServiceImpl extends ServiceImpl<SaleMapper, Sale> implements SaleService {

    @Resource
    SaleMapper saleMapper;

    @Resource
    SaleMaterialService saleMaterialService;

    @Resource
    SaleMaterialMapper saleMaterialMapper;

    //查询销售单列表
    @Override
    public IPage<Map<String, Object>> selectSaleList(Page<Object> page, String orderNumber, String name, Integer type, String delTime) {
        return saleMapper.selectSaleList(page, orderNumber, name, type, delTime);
    }

    //新增销售单
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String addSale(String saleman, SaleDto saleDto) {
        Sale sale = new Sale();
        BeanUtils.copyProperties(saleDto, sale);
        sale.setSaleman(saleman);
        sale.setOrderType("手工订单");
        saleMapper.insert(sale);
        //添加销售产品单
        List<SaleMaterialDto> saleMaterialDtoList = saleDto.getSaleMaterialList();
        for (SaleMaterialDto saleMaterialDto : saleMaterialDtoList) {
            SaleMaterial saleMaterial = new SaleMaterial();
            BeanUtils.copyProperties(saleMaterialDto, saleMaterial);
            saleMaterial.setSaleId(sale.getId());
            saleMaterialMapper.insert(saleMaterial);
        }
        return "新增成功";
    }

    //根据销售单id查询销售详情
    @Override
    public SaleVo selectSaleDatil(Integer id) {
        SaleVo saleVo = new SaleVo();
        Sale sale = saleMapper.selectById(id);
        BeanUtils.copyProperties(sale, saleVo);
        List<SaleMaterial> saleMaterialList = saleMaterialMapper.selectSaleDatil(id);//销售单id
        List<SaleMaterialDto> saleMaterialDtoList = saleMaterialList.stream().map(saleMaterial -> {
            SaleMaterialDto saleMaterialDto = new SaleMaterialDto();
            BeanUtils.copyProperties(saleMaterial, saleMaterialDto);
            return saleMaterialDto;
        }).collect(Collectors.toList());
        saleVo.setSaleMaterialList(saleMaterialDtoList);
        return saleVo;
    }

    //根据销售单id删除
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delSale(Integer id) {
        Sale sale = saleMapper.selectById(id);
        sale.setState(0);
        saleMapper.updateById(sale);
        List<SaleMaterial> saleMaterials = saleMaterialMapper.selectSaleDatil(id);
        for (SaleMaterial saleMaterial : saleMaterials) {
            saleMaterial.setState(0);
            saleMaterialMapper.updateById(saleMaterial);
        }
    }

    //根据id批量删除
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delAllSale(String ids) {
        //批量删除销售单
        saleMapper.delAllSale(ids);
        //批量删除销售产品单
        saleMaterialMapper.delAllSale(ids);
    }

    //根据销售单id修改信息
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String updateSaleById(String saleman, Integer id, SaleVo saleVo) {
        //校验,同一个产品的规格型号不能相同
        List<SaleMaterialDto> saleMaterialList = saleVo.getSaleMaterialList();
        // 使用哈希集合来判断是否存在相同字段值组合
        Set<String> seen = new HashSet<>();
        for (SaleMaterialDto saleMaterial : saleMaterialList) {
            String key = saleMaterial.getName() + "," + saleMaterial.getSpecifications();
            if (seen.contains(key)) {
                return "同一个产品的规格型号不能相同";
            } else {
                seen.add(key);
            }
        }
        Sale sale = saleMapper.selectById(id);
        sale.setSaleman(saleman);
        BeanUtils.copyProperties(saleVo, sale);
        //更新销售单
        saleMapper.updateById(sale);
        List<SaleMaterialDto> saleMaterialDtos = saleVo.getSaleMaterialList();
        for (SaleMaterialDto saleMaterialDto : saleMaterialDtos) {
            SaleMaterial saleMaterial = new SaleMaterial();
            BeanUtils.copyProperties(saleMaterialDto, saleMaterial);
            saleMaterialMapper.updateById(saleMaterial);
        }
        return "修改成功!";
    }

    //审核
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void check(String checkname, Integer id, Integer type) {
        Sale sale = saleMapper.selectById(id);
        sale.setType(type);
        sale.setCheckname(checkname);
        sale.setCheckTime(new Date());
        saleMapper.updateById(sale);
        //审核通过的销售单将销售单中的产品的状态改为待编制0
        List<SaleMaterial> saleMaterials = saleMaterialMapper.selectList(Wrappers.<SaleMaterial>query()
                .eq("sale_id", id)
                .eq("state", 1));
        if (type == 1) {
            for (SaleMaterial saleMaterial : saleMaterials) {
                saleMaterial.setType(0);
                saleMaterialMapper.updateById(saleMaterial);
            }
        }
    }

    //根据订单号查询销售信息
    @Override
    public ConsignmentDto1 selSale(String orderNumber) {
        Sale sale = saleMapper.selectOne(Wrappers.<Sale>query()
                .eq("order_number", orderNumber)
                .eq("type", 1)
                .eq("state", 1));
        //查询销售单中产品信息
        List<SaleMaterial> saleMaterials = saleMaterialMapper.selectList(Wrappers.<SaleMaterial>query()
                .eq("sale_id", sale.getId())
                .eq("state", 1));
        List<ConsignmentDto2> dto2List = saleMaterials.stream().map(saleMaterial -> {
            ConsignmentDto2 consignmentDto2 = new ConsignmentDto2();
            BeanUtils.copyProperties(saleMaterial, consignmentDto2);
            return consignmentDto2;
        }).collect(Collectors.toList());
        ConsignmentDto1 consignmentDto1 = ConsignmentDto1.builder()
                .orderCode(orderNumber)
                .customerCode(sale.getCode())
                .proname(sale.getProname())
                .messages(dto2List)
                .build();
        return consignmentDto1;
    }

    //同步销售数据
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String synchronization() {
        //当天时间的凌晨4点开始同步
        String pattern = "yyyy-MM-dd HH:mm:ss";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        String dateTime = LocalDateTime.now().with(LocalTime.of(4, 0, 0)).format(formatter);
        //获取主销售数据
        List<Map<String, Object>> order = SyncOrder.getMainOrder(dateTime);
        List<Sale> list = order.stream().map(orde -> {
            Sale sale = new Sale();
            sale.setOrderNumber(orde.get("orderNo").toString());//订单编号
            sale.setCode(String.valueOf(orde.get("customerContractNumber")));//客户合同编号
            sale.setName(orde.get("projectName").toString());//工程名称
            sale.setProname(orde.get("customerName").toString());//客户名称
            sale.setOrderName(orde.get("createdName").toString());//下单人
            sale.setSaleman(orde.get("salesmanName").toString());//业务员
            sale.setDelTime(DateUtil.parseDate(orde.get("wantedDeliveryDate").toString()));//交货日期
            sale.setCreateTime(DateUtil.parseDate(orde.get("orderDate").toString()));//下单日期
            sale.setNote(String.valueOf(orde.get("comment")));//备注
            sale.setOrderId((Integer) orde.get("id"));  //otc订单id
            sale.setOrderType(orde.get("orderClassification").toString()); //订单类型
            return sale;
        }).collect(Collectors.toList());
        //去重
        list.removeIf(sale -> ObjectUtils.isNotEmpty(saleMapper.selectOne(Wrappers.<Sale>query().eq("order_number", sale.getOrderNumber()))));
        this.saveBatch(list);
        for (Sale sale : list) {
            List<Map<String, Object>> innerOrder = SyncOrder.getInnerOrder(dateTime, sale.getOrderNumber());
            List<SaleMaterial> saleMaterials = innerOrder.stream().map(inorder -> {
                SaleMaterial saleMaterial = new SaleMaterial();
                saleMaterial.setName(inorder.get("productName").toString()); //产品名称
                saleMaterial.setSpecifications(inorder.get("specificationModel").toString()); //产品规格型号
                saleMaterial.setUnit(inorder.get("unit").toString());   //单位
                saleMaterial.setNumber((int) Double.parseDouble(inorder.get("quantity").toString()));  //数量
                saleMaterial.setPrice(inorder.get("unitPriceInclTax").toString());  //单价
                saleMaterial.setSaleId(sale.getId());  //关联 销售单id
                saleMaterial.setAdress(String.valueOf(inorder.get("shippingAddress")));  //收货地址
                saleMaterial.setUsername(String.valueOf(inorder.get("receivingContact")));  //联系人
                saleMaterial.setPhone(String.valueOf(inorder.get("receivingContactPhone")));  //手机号
                return saleMaterial;
            }).collect(Collectors.toList());
            saleMaterialService.saveBatch(saleMaterials);
        }
        return "同步成功!";
    }


    //下载附件
    @Override
    public List<String> download(Integer id) {
        Integer orderId = saleMapper.selectById(id).getOrderId();
        List<Map<String, Object>> attachment = SyncOrder.getAttachmentByOrderId(orderId);
        List<String> list = new ArrayList<>();
        if (ObjectUtils.isEmpty(attachment)) {
            list.add("该订单没有附件");
            return list;
        }
        for (Map<String, Object> attch : attachment) {
            String path = attch.get("path").toString();
            list.add(path);
        }
        return list;
    }
}