package com.ruoyi.production.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.procurementrecord.dto.ProcurementRecordOutPageDto;
import com.ruoyi.production.dto.ProcessSchedulingDto;
import com.ruoyi.production.dto.ProductionDispatchAddDto;
import com.ruoyi.production.dto.SalesLedgerSchedulingDto;
import com.ruoyi.production.dto.SalesLedgerSchedulingProcessDto;
import com.ruoyi.production.mapper.SalesLedgerSchedulingMapper;
import com.ruoyi.production.mapper.SalesLedgerWorkMapper;
import com.ruoyi.production.pojo.SalesLedgerScheduling;
import com.ruoyi.production.pojo.SalesLedgerWork;
import com.ruoyi.production.service.SalesLedgerSchedulingService;
import com.ruoyi.project.system.domain.SysUser;
import com.ruoyi.project.system.mapper.SysUserMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.servlet.http.HttpServletResponse;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * @author :yys
 * @date : 2025/7/21 14:41
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class SalesLedgerSchedulingServiceImpl extends ServiceImpl<SalesLedgerSchedulingMapper, SalesLedgerScheduling> implements SalesLedgerSchedulingService {

    private final SalesLedgerSchedulingMapper salesLedgerSchedulingMapper;

    private final SalesLedgerWorkMapper salesLedgerWorkMapper;

    @Override
    public IPage<SalesLedgerSchedulingDto> listPage(Page page, SalesLedgerSchedulingDto salesLedgerSchedulingDto) {
        IPage<SalesLedgerSchedulingDto> list = salesLedgerSchedulingMapper.listPage(page, salesLedgerSchedulingDto);
        if(list.getTotal() == 0){
            return list;
        }
        Set<Long> collect = list.getRecords().stream().map(SalesLedgerSchedulingDto::getSalesLedgerProductId).collect(Collectors.toSet());
        LambdaQueryWrapper<SalesLedgerWork> salesLedgerWorkLambdaQueryWrapper = new LambdaQueryWrapper<>();
        salesLedgerWorkLambdaQueryWrapper.in(SalesLedgerWork::getSalesLedgerProductId, collect)
                .ne(SalesLedgerWork::getStatus, 1);
        List<SalesLedgerWork> salesLedgerWorks = salesLedgerWorkMapper.selectList(salesLedgerWorkLambdaQueryWrapper);
        list.getRecords().forEach(i -> {
            // 获取完成数量
            i.setSuccessNum(salesLedgerWorks
                    .stream()
                    .filter(j -> j.getSalesLedgerProductId().equals(i.getSalesLedgerProductId()))
                    .map(SalesLedgerWork::getFinishedNum)
                    .reduce(BigDecimal.ZERO, BigDecimal::add));
        });
        return list;
    }

    @Override
    public void export(HttpServletResponse response) {
        List<SalesLedgerSchedulingDto> list = salesLedgerSchedulingMapper.list();
        if(CollectionUtils.isEmpty(list)){
            throw new RuntimeException("无导出数据");
        }
        Set<Long> collect = list.stream().map(SalesLedgerSchedulingDto::getSalesLedgerProductId).collect(Collectors.toSet());
        LambdaQueryWrapper<SalesLedgerWork> salesLedgerWorkLambdaQueryWrapper = new LambdaQueryWrapper<>();
        salesLedgerWorkLambdaQueryWrapper.in(SalesLedgerWork::getSalesLedgerProductId, collect)
                .ne(SalesLedgerWork::getStatus, 1);
        List<SalesLedgerWork> salesLedgerWorks = salesLedgerWorkMapper.selectList(salesLedgerWorkLambdaQueryWrapper);
        list.forEach(i -> {
            // 获取完成数量
            i.setSuccessNum(salesLedgerWorks
                    .stream()
                    .filter(j -> j.getSalesLedgerProductId().equals(i.getSalesLedgerProductId()))
                    .map(SalesLedgerWork::getFinishedNum)
                    .reduce(BigDecimal.ZERO, BigDecimal::add));
        });
        ExcelUtil<SalesLedgerSchedulingDto> util = new ExcelUtil<>(SalesLedgerSchedulingDto.class);
        util.exportExcel(response, list, "生产订单");
    }

    private final SysUserMapper sysUserMapper;

    @Override
    public int productionDispatch(ProductionDispatchAddDto productionDispatchAddDto) {
        SysUser sysUser = sysUserMapper.selectUserById(productionDispatchAddDto.getSchedulingUserId());
        if(sysUser == null) throw new RuntimeException("排产人不存在");
        SalesLedgerScheduling salesLedgerScheduling = SalesLedgerScheduling.builder()
                .salesLedgerId(productionDispatchAddDto.getSalesLedgerId())
                .salesLedgerProductId(productionDispatchAddDto.getSalesLedgerProductId())
                .schedulingUserId(productionDispatchAddDto.getSchedulingUserId())
                .schedulingUserName(sysUser.getNickName())
                .schedulingNum(productionDispatchAddDto.getSchedulingNum())
                .schedulingDate(LocalDate.parse(productionDispatchAddDto.getSchedulingDate(), DateTimeFormatter.ISO_LOCAL_DATE))
                .status(1)
                .build();
        return salesLedgerSchedulingMapper.insert(salesLedgerScheduling);
    }

    @Override
    public IPage<SalesLedgerSchedulingProcessDto> listPageProcess(Page page, SalesLedgerSchedulingProcessDto salesLedgerSchedulingDto) {
        IPage<SalesLedgerSchedulingProcessDto> list = salesLedgerSchedulingMapper.listPageProcess(page, salesLedgerSchedulingDto);
        Set<Long> collect = list.getRecords().stream().map(SalesLedgerSchedulingProcessDto::getSalesLedgerProductId).collect(Collectors.toSet());
        LambdaQueryWrapper<SalesLedgerWork> salesLedgerWorkLambdaQueryWrapper = new LambdaQueryWrapper<>();
        salesLedgerWorkLambdaQueryWrapper.in(SalesLedgerWork::getSalesLedgerProductId, collect)
                .ne(SalesLedgerWork::getStatus, 1);
        List<SalesLedgerWork> salesLedgerWorks = salesLedgerWorkMapper.selectList(salesLedgerWorkLambdaQueryWrapper);
        list.getRecords().forEach(i -> {
            // 获取完成数量
            i.setSuccessNum(salesLedgerWorks
                    .stream()
                    .filter(j -> j.getSalesLedgerProductId().equals(i.getSalesLedgerProductId()))
                    .map(SalesLedgerWork::getFinishedNum)
                    .reduce(BigDecimal.ZERO, BigDecimal::add));
        });
        return list;
    }

    @Override
    public int productionDispatchDelete(List<Long> ids) {
        LambdaQueryWrapper<SalesLedgerScheduling> salesLedgerSchedulingLambdaQueryWrapper = new LambdaQueryWrapper<SalesLedgerScheduling>();
        salesLedgerSchedulingLambdaQueryWrapper.in(SalesLedgerScheduling::getId, ids);
        List<SalesLedgerScheduling> salesLedgerSchedulings = salesLedgerSchedulingMapper.selectList(salesLedgerSchedulingLambdaQueryWrapper);
        if(CollectionUtils.isEmpty(salesLedgerSchedulings)) throw new RuntimeException("排产不存在");
        List<SalesLedgerScheduling> collect = salesLedgerSchedulings.stream().filter(i -> !i.getStatus().equals(1)).collect(Collectors.toList());
        if(!CollectionUtils.isEmpty(collect)) throw new RuntimeException("排产已开始，请勿删除");
        salesLedgerSchedulingMapper.deleteBatchIds(ids);
        return 0;
    }

    @Override
    public int processScheduling(List<ProcessSchedulingDto> processSchedulingDtos) {
        for (ProcessSchedulingDto processSchedulingDto : processSchedulingDtos) {
            SalesLedgerScheduling salesLedgerScheduling = salesLedgerSchedulingMapper.selectById(processSchedulingDto.getId());
            if(salesLedgerScheduling == null) throw new RuntimeException("排产不存在");
            if(salesLedgerScheduling.getStatus().equals(3)) throw new RuntimeException("排产已完成，请勿重复排产");
            SysUser sysUser = sysUserMapper.selectUserById(processSchedulingDto.getSchedulingUserId());
            if(sysUser == null) throw new RuntimeException("排产人不存在");
            salesLedgerScheduling.setFinishedNum(salesLedgerScheduling.getFinishedNum().add(processSchedulingDto.getSchedulingNum()));
            if(salesLedgerScheduling.getSchedulingNum().compareTo(salesLedgerScheduling.getFinishedNum()) <= 0){
                salesLedgerScheduling.setStatus(3);
            }else{
                salesLedgerScheduling.setStatus(2);
            }
            salesLedgerSchedulingMapper.updateById(salesLedgerScheduling);
            SalesLedgerWork.SalesLedgerWorkBuilder salesLedgerWorkBuilder = SalesLedgerWork.builder()
                    .salesLedgerSchedulingId(salesLedgerScheduling.getId())
                    .salesLedgerId(salesLedgerScheduling.getSalesLedgerId())
                    .salesLedgerProductId(salesLedgerScheduling.getSalesLedgerProductId())
                    .schedulingUserId(salesLedgerScheduling.getSchedulingUserId())
                    .schedulingUserName(sysUser.getNickName())
                    .schedulingNum(processSchedulingDto.getSchedulingNum())
                    .workHours(processSchedulingDto.getWorkHours())
                    .process(processSchedulingDto.getProcess())
                    .status(1)
                    .schedulingDate(LocalDate.parse(processSchedulingDto.getSchedulingDate(), DateTimeFormatter.ISO_LOCAL_DATE));
            salesLedgerWorkMapper.insert(salesLedgerWorkBuilder.build());
        }
        return 0;
    }
}