package com.klp.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.domain.WmsActualWarehouse;
import com.klp.domain.WmsMaterialCoil;
import com.klp.domain.bo.WmsMaterialCoilBo;
import com.klp.domain.vo.WmsActualWarehouseVo;
import com.klp.mapper.WmsActualWarehouseMapper;
import com.klp.service.IWmsMaterialCoilService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.domain.bo.WmsCoilWarehouseOperationLogBo;
import com.klp.domain.vo.WmsCoilWarehouseOperationLogVo;
import com.klp.domain.vo.WmsCoilWarehouseOperationLogExportVo;
import com.klp.domain.vo.WmsMaterialCoilVo;
import com.klp.domain.WmsCoilWarehouseOperationLog;
import com.klp.mapper.WmsCoilWarehouseOperationLogMapper;
import com.klp.service.IWmsCoilWarehouseOperationLogService;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 钢卷库区操作记录Service业务层处理
 *
 * @author klp
 * @date 2026-03-05
 */
@RequiredArgsConstructor
@Service
public class WmsCoilWarehouseOperationLogServiceImpl implements IWmsCoilWarehouseOperationLogService {

    private final WmsCoilWarehouseOperationLogMapper baseMapper;
    private final WmsActualWarehouseMapper wmsActualWarehouseMapper;
    private final IWmsMaterialCoilService wmsMaterialCoilService;

    /**
     * 查询钢卷库区操作记录
     */
    @Override
    public WmsCoilWarehouseOperationLogVo queryById(Long logId){
        return baseMapper.selectVoById(logId);
    }

    /**
     * 查询钢卷库区操作记录列表
     */
    @Override
    public TableDataInfo<WmsCoilWarehouseOperationLogVo> queryPageList(WmsCoilWarehouseOperationLogBo bo, PageQuery pageQuery) {
        LambdaQueryWrapper<WmsCoilWarehouseOperationLog> lqw = buildQueryWrapper(bo);
        Page<WmsCoilWarehouseOperationLogVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
        return TableDataInfo.build(result);
    }

    /**
     * 查询钢卷库区操作记录列表
     */
    @Override
    public List<WmsCoilWarehouseOperationLogVo> queryList(WmsCoilWarehouseOperationLogBo bo) {
        LambdaQueryWrapper<WmsCoilWarehouseOperationLog> lqw = buildQueryWrapper(bo);
        return baseMapper.selectVoList(lqw);
    }

    private LambdaQueryWrapper<WmsCoilWarehouseOperationLog> buildQueryWrapper(WmsCoilWarehouseOperationLogBo bo) {
        Map<String, Object> params = bo.getParams();
        LambdaQueryWrapper<WmsCoilWarehouseOperationLog> lqw = Wrappers.lambdaQuery();
        lqw.eq(bo.getCoilId() != null, WmsCoilWarehouseOperationLog::getCoilId, bo.getCoilId());
        lqw.eq(bo.getActualWarehouseId() != null, WmsCoilWarehouseOperationLog::getActualWarehouseId, bo.getActualWarehouseId());
        lqw.eq(bo.getOperationType() != null, WmsCoilWarehouseOperationLog::getOperationType, bo.getOperationType());
        lqw.eq(bo.getInOutType() != null, WmsCoilWarehouseOperationLog::getInOutType, bo.getInOutType());
        return lqw;
    }

    /**
     * 新增钢卷库区操作记录
     */
    @Override
    public Boolean insertByBo(WmsCoilWarehouseOperationLogBo bo) {
        WmsCoilWarehouseOperationLog add = BeanUtil.toBean(bo, WmsCoilWarehouseOperationLog.class);
        validEntityBeforeSave(add);
        boolean flag = baseMapper.insert(add) > 0;
        if (flag) {
            bo.setLogId(add.getLogId());
        }
        return flag;
    }

    /**
     * 修改钢卷库区操作记录
     */
    @Override
    public Boolean updateByBo(WmsCoilWarehouseOperationLogBo bo) {
        WmsCoilWarehouseOperationLog update = BeanUtil.toBean(bo, WmsCoilWarehouseOperationLog.class);
        validEntityBeforeSave(update);
        return baseMapper.updateById(update) > 0;
    }

    /**
     * 保存前的数据校验
     */
    private void validEntityBeforeSave(WmsCoilWarehouseOperationLog entity){
        //TODO 做一些数据校验,如唯一约束
    }

    /**
     * 批量删除钢卷库区操作记录
     */
    @Override
    public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
        if(isValid){
            //TODO 做一些业务上的校验,判断是否需要校验
        }
        return baseMapper.deleteBatchIds(ids) > 0;
    }

    @Override
    public boolean deleteByCoilIdAndTypes(Long coilId, String operationType, String inOutType) {
        LambdaQueryWrapper<WmsCoilWarehouseOperationLog> lqw = Wrappers.lambdaQuery();
        lqw.eq(WmsCoilWarehouseOperationLog::getCoilId, coilId);
        lqw.eq(WmsCoilWarehouseOperationLog::getOperationType, operationType);
        lqw.eq(WmsCoilWarehouseOperationLog::getInOutType, inOutType);
        return baseMapper.delete(lqw) > 0;
    }

    @Override
    public List<WmsCoilWarehouseOperationLogVo> queryBySecondWarehouseIdAndTimeRange(Long secondWarehouseId, Integer operationType, Integer inOutType, Date startTime, Date endTime) {
        Set<Long> warehouseIds = getAllChildWarehouseIds(secondWarehouseId);
        if (warehouseIds.isEmpty()) {
            return new ArrayList<>();
        }

        List<WmsCoilWarehouseOperationLogVo> list = baseMapper.selectVoListWithJoin(new ArrayList<>(warehouseIds), operationType, inOutType, startTime, endTime);

        for (WmsCoilWarehouseOperationLogVo vo : list) {
            if (vo.getCoil() != null) {
                buildItemObjectFromJoin(vo.getCoil());
            }
        }

        return list;
    }

    private void buildItemObjectFromJoin(WmsMaterialCoilVo vo) {
        // no-op: WmsMaterialCoilVo 改为仅返回扁平字段，不再构建嵌套对象
    }

    private Set<Long> getAllChildWarehouseIds(Long parentId) {
        Set<Long> result = new HashSet<>();
        if (parentId == null) {
            return result;
        }
        result.add(parentId);
        LambdaQueryWrapper<WmsActualWarehouse> lqw = Wrappers.lambdaQuery();
        lqw.select(WmsActualWarehouse::getActualWarehouseId, WmsActualWarehouse::getParentId);
        List<WmsActualWarehouse> allWarehouses = wmsActualWarehouseMapper.selectList(lqw);
        Map<Long, List<Long>> parentChildrenMap = allWarehouses.stream()
            .filter(w -> w.getParentId() != null)
            .collect(java.util.stream.Collectors.groupingBy(
                WmsActualWarehouse::getParentId,
                java.util.stream.Collectors.mapping(WmsActualWarehouse::getActualWarehouseId, java.util.stream.Collectors.toList())
            ));
        java.util.Queue<Long> queue = new java.util.LinkedList<>();
        queue.offer(parentId);
        while (!queue.isEmpty()) {
            Long currentId = queue.poll();
            List<Long> children = parentChildrenMap.get(currentId);
            if (children != null && !children.isEmpty()) {
                result.addAll(children);
                queue.addAll(children);
            }
        }
        return result;
    }

    @Override
    public List<WmsCoilWarehouseOperationLogVo> queryByCoilId(Long coilId, Integer operationType, Integer inOutType, Date startTime, Date endTime) {
        LambdaQueryWrapper<WmsCoilWarehouseOperationLog> lqw = Wrappers.lambdaQuery();
        lqw.eq(WmsCoilWarehouseOperationLog::getCoilId, coilId);
        lqw.eq(operationType != null, WmsCoilWarehouseOperationLog::getOperationType, operationType);
        lqw.eq(inOutType != null, WmsCoilWarehouseOperationLog::getInOutType, inOutType);
        lqw.ge(startTime != null, WmsCoilWarehouseOperationLog::getCreateTime, startTime);
        lqw.le(endTime != null, WmsCoilWarehouseOperationLog::getCreateTime, endTime);
        lqw.orderByDesc(WmsCoilWarehouseOperationLog::getCreateTime);

        List<WmsCoilWarehouseOperationLogVo> list = baseMapper.selectVoList(lqw);

        Set<Long> coilIds = list.stream()
            .map(WmsCoilWarehouseOperationLogVo::getCoilId)
            .filter(Objects::nonNull)
            .collect(Collectors.toSet());

        Set<Long> warehouseIds = list.stream()
            .map(WmsCoilWarehouseOperationLogVo::getActualWarehouseId)
            .filter(Objects::nonNull)
            .collect(Collectors.toSet());

        Map<Long, WmsMaterialCoilVo> coilMap = new HashMap<>();
        if (!coilIds.isEmpty()) {
            WmsMaterialCoilBo bo = new WmsMaterialCoilBo();
            bo.setCoilIds(coilIds.stream().map(String::valueOf).collect(Collectors.joining(",")));
            List<WmsMaterialCoilVo> coils = wmsMaterialCoilService.queryList(bo);
            for (WmsMaterialCoilVo coil : coils) {
                coilMap.put(coil.getCoilId(), coil);
            }
        }

        Map<Long, WmsActualWarehouseVo> warehouseMap = new HashMap<>();
        if (!warehouseIds.isEmpty()) {
            LambdaQueryWrapper<WmsActualWarehouse> warehouseQuery = Wrappers.lambdaQuery();
            warehouseQuery.in(WmsActualWarehouse::getActualWarehouseId, warehouseIds);
            List<WmsActualWarehouse> warehouses = wmsActualWarehouseMapper.selectList(warehouseQuery);
            for (WmsActualWarehouse warehouse : warehouses) {
                WmsActualWarehouseVo vo = BeanUtil.toBean(warehouse, WmsActualWarehouseVo.class);
                warehouseMap.put(warehouse.getActualWarehouseId(), vo);
            }
        }

        for (WmsCoilWarehouseOperationLogVo vo : list) {
            vo.setCoil(coilMap.get(vo.getCoilId()));
            vo.setWarehouse(warehouseMap.get(vo.getActualWarehouseId()));
        }

        return list;
    }

    @Override
    public List<WmsCoilWarehouseOperationLogExportVo> exportBySecondWarehouseIdAndTimeRange(Long secondWarehouseId, Integer operationType, Integer inOutType, Date startTime, Date endTime) {
        List<WmsCoilWarehouseOperationLogVo> voList = queryBySecondWarehouseIdAndTimeRange(secondWarehouseId, operationType, inOutType, startTime, endTime);

        List<WmsCoilWarehouseOperationLogExportVo> exportList = new ArrayList<>();
        for (WmsCoilWarehouseOperationLogVo vo : voList) {
            WmsCoilWarehouseOperationLogExportVo exportVo = new WmsCoilWarehouseOperationLogExportVo();

            WmsMaterialCoilVo coil = vo.getCoil();
            if (coil != null) {
                exportVo.setEnterCoilNo(coil.getEnterCoilNo());
                exportVo.setCurrentCoilNo(coil.getCurrentCoilNo());
                exportVo.setSupplierCoilNo(coil.getSupplierCoilNo());
                exportVo.setNetWeight(coil.getNetWeight());
                exportVo.setItemTypeDesc(coil.getItemType());
                exportVo.setPurpose(coil.getBusinessPurpose());
                exportVo.setTrimmingRequirement(coil.getTrimmingRequirement());
                exportVo.setPackagingRequirement(coil.getPackagingRequirement());
                exportVo.setQualityStatus(coil.getQualityStatus());
                exportVo.setPackingStatus(coil.getPackingStatus());
                exportVo.setStatusDesc(getStatusDesc(coil.getStatus()));
                exportVo.setItemName(coil.getItemName());
                exportVo.setSpecification(coil.getSpecification());
                exportVo.setLength(coil.getLength());
                exportVo.setMaterial(coil.getMaterial());
                exportVo.setManufacturer(coil.getManufacturer());
                exportVo.setSurfaceTreatmentDesc(coil.getSurfaceTreatmentDesc());
                exportVo.setZincLayer(coil.getZincLayer());
                exportVo.setCreateTime(coil.getCreateTime());
                exportVo.setLogicalWarehouseName(coil.getWarehouseName());
                exportVo.setActualWarehouseName(coil.getActualWarehouseName());
            }

            WmsActualWarehouseVo warehouse = vo.getWarehouse();
            if (warehouse != null) {
                exportVo.setWarehouseName(warehouse.getActualWarehouseName());
            }

            exportVo.setOperationTypeDesc(getOperationTypeDesc(vo.getOperationType()));
            exportVo.setInOutTypeDesc(getInOutTypeDesc(vo.getInOutType()));
            exportVo.setCreateBy(vo.getCreateBy());
            exportVo.setCreateTimeLog(vo.getCreateTime());
            exportVo.setRemark(vo.getRemark());

            exportList.add(exportVo);
        }

        return exportList;
    }

    private String getStatusDesc(Integer status) {
        if (status == null) return null;
        switch (status) {
            case 0: return "在库";
            case 1: return "在途";
            case 2: return "已出库";
            default: return String.valueOf(status);
        }
    }

    private String getOperationTypeDesc(Integer operationType) {
        if (operationType == null) return null;
        switch (operationType) {
            case 1: return "收货";
            case 2: return "加工";
            case 3: return "调拨";
            case 4: return "发货";
            default: return String.valueOf(operationType);
        }
    }

    private String getInOutTypeDesc(Integer inOutType) {
        if (inOutType == null) return null;
        switch (inOutType) {
            case 1: return "入库";
            case 2: return "出库";
            default: return String.valueOf(inOutType);
        }
    }
}