package com.ruoyi.business.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.basic.entity.CoalInfo;
import com.ruoyi.basic.mapper.CoalInfoMapper;
import com.ruoyi.business.dto.ProductionMasterDto;
import com.ruoyi.business.entity.*;
import com.ruoyi.business.mapper.*;
import com.ruoyi.business.service.ProductionMasterService;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.bean.BeanUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * <p>
 * 生产主表 服务实现类
 * </p>
 *
 * @author ruoyi
 * @since 2025-06-13
 */
@Service
@RequiredArgsConstructor
public class ProductionMasterServiceImpl extends ServiceImpl<ProductionMasterMapper, ProductionMaster> implements ProductionMasterService {

    private final ProductionMasterMapper productionMasterMapper;

    private final ProductionInventoryMapper productionInventoryMapper;

    private final ProductionMapper productionMapper;

    private final OfficialInventoryMapper officialInventoryMapper;

    private final CoalInfoMapper coalInfoMapper;

    private final PendingInventoryMapper pendingInventoryMapper;

    @Override
    public IPage<ProductionMasterDto> selectPMList(Page page, ProductionMasterDto productionMasterDto) {
        // 1. 构建主表查询条件
        LambdaQueryWrapper<ProductionMaster> masterQueryWrapper = new LambdaQueryWrapper<>();

        // 2. 执行主表分页查询
        IPage<ProductionMaster> entityPage = productionMasterMapper.selectPage(page, masterQueryWrapper);

        // 3. 提取主表ID列表用于批量查询子表数据
        List<Long> masterIds = entityPage.getRecords().stream()
                .map(ProductionMaster::getId)
                .collect(Collectors.toList());

        // 4. 批量查询关联数据（避免N+1问题）
        Map<Long, List<Production>> productionMap = queryProductionByMasterIds(masterIds);
        Map<Long, List<ProductionInventory>> inventoryMap = queryInventoryByMasterIds(masterIds);

        // 5. 转换数据并组装结果
        List<ProductionMasterDto> dtoList = entityPage.getRecords().stream()
                .map(record -> {
                    ProductionMasterDto dto = new ProductionMasterDto();
                    BeanUtils.copyProperties(record, dto);
                    dto.setProductionList(productionMap.getOrDefault(record.getId(), Collections.emptyList()));
                    dto.setProductionInventoryList(inventoryMap.getOrDefault(record.getId(), Collections.emptyList()));
                    return dto;
                })
                .collect(Collectors.toList());

        // 6. 构建返回结果
        IPage<ProductionMasterDto> dtoPage = new Page<>();
        BeanUtils.copyProperties(entityPage, dtoPage, "records");
        dtoPage.setRecords(dtoList);

        return dtoPage;
    }

    /**
     * 批量查询Production数据
     */
    private Map<Long, List<Production>> queryProductionByMasterIds(List<Long> masterIds) {
        if (masterIds.isEmpty()) {
            return Collections.emptyMap();
        }

        LambdaQueryWrapper<Production> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(Production::getProductionMasterId, masterIds);
        List<Production> productions = productionMapper.selectList(queryWrapper);

        return productions.stream()
                .collect(Collectors.groupingBy(Production::getProductionMasterId));
    }

    /**
     * 批量查询ProductionInventory数据
     */
    private Map<Long, List<ProductionInventory>> queryInventoryByMasterIds(List<Long> masterIds) {
        if (masterIds.isEmpty()) {
            return Collections.emptyMap();
        }

        LambdaQueryWrapper<ProductionInventory> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(ProductionInventory::getProductionMasterId, masterIds);
        List<ProductionInventory> inventoryList = productionInventoryMapper.selectList(queryWrapper);

        return inventoryList.stream()
                .collect(Collectors.groupingBy(ProductionInventory::getProductionMasterId));
    }

    @Override
    @Transactional
    public int addOrEditPM(ProductionMasterDto dto) {
        Long masterId = dto.getId();

        // 编辑场景：回滚旧库存并删除旧记录
        if (masterId != null) {
            rollbackOldInventory(masterId);
            deleteChildRecords(masterId);
        }

        // 校验使用量并减少库存
        validateAndReduceInventory(dto.getProductionInventoryList());

        // 构造主表实体对象
        ProductionMaster master = buildProductionMaster(dto);

        // 插入或更新主表
        if (masterId == null) {
            productionMasterMapper.insert(master);
            masterId = master.getId();
        } else {
            master.setId(masterId);
            productionMasterMapper.updateById(master);
        }

        // 批量插入生产记录与库存记录
        batchInsertProductions(masterId, dto.getProductionList());
        batchInsertInventories(masterId, dto.getProductionInventoryList());

        // 插入待入库数据
        insertPendingInventory(dto.getProductionList());

        return 1;
    }

    /**
     * 回滚旧的库存数据（将库存数量还原）
     */
    private void rollbackOldInventory(Long masterId) {
        List<ProductionInventory> oldInventories = productionInventoryMapper.selectList(
                new LambdaQueryWrapper<ProductionInventory>().eq(ProductionInventory::getProductionMasterId, masterId));

        for (ProductionInventory oldInv : oldInventories) {
            OfficialInventory inv = officialInventoryMapper.selectById(oldInv.getOfficialId());
            if (inv != null) {
                inv.setInventoryQuantity(inv.getInventoryQuantity().add(new BigDecimal(oldInv.getUsedQuantity())));
                officialInventoryMapper.updateById(inv);
            }
        }
    }

    /**
     * 删除旧的子表数据及待入库数据
     */
    private void deleteChildRecords(Long masterId) {
        productionMapper.delete(new LambdaQueryWrapper<Production>().eq(Production::getProductionMasterId, masterId));
        productionInventoryMapper.delete(new LambdaQueryWrapper<ProductionInventory>().eq(ProductionInventory::getProductionMasterId, masterId));
        pendingInventoryMapper.delete(new LambdaQueryWrapper<PendingInventory>().eq(PendingInventory::getMasterId, masterId));
    }

    /**
     * 校验每条使用量是否足够，并减少正式库存数量
     */
    private void validateAndReduceInventory(List<ProductionInventory> inventoryList) {
        for (ProductionInventory inv : inventoryList) {
            OfficialInventory official = officialInventoryMapper.selectById(inv.getOfficialId());
            BigDecimal used = new BigDecimal(inv.getUsedQuantity());
            if (official.getInventoryQuantity().compareTo(used) < 0) {
                throw new BaseException("库存不足");
            }
            official.setInventoryQuantity(official.getInventoryQuantity().subtract(used));
            officialInventoryMapper.updateById(official);
        }
    }

    /**
     * 构造主表对象并聚合字段值（如总成本、煤种等）
     */
    private ProductionMaster buildProductionMaster(ProductionMasterDto dto) {
        BigDecimal totalPurchase = BigDecimal.ZERO;
        BigDecimal totalLabor = BigDecimal.ZERO;
        BigDecimal totalEnergy = BigDecimal.ZERO;
        BigDecimal totalCost = BigDecimal.ZERO;
        BigDecimal totalDepreciation = BigDecimal.ZERO;
        BigDecimal totalQuantity = BigDecimal.ZERO;

        List<Long> coalIds = new ArrayList<>();

        for (Production p : dto.getProductionList()) {
            totalPurchase = totalPurchase.add(p.getPurchasePrice());
            totalLabor = totalLabor.add(p.getLaborCost());
            totalEnergy = totalEnergy.add(p.getEnergyConsumptionCost());
            totalCost = totalCost.add(p.getTotalCost());
            totalDepreciation = totalDepreciation.add(p.getEquipmentDepreciation());
            totalQuantity = totalQuantity.add(p.getProductionQuantity());
            coalIds.add(p.getCoalId());
        }

        List<CoalInfo> coalInfos = coalInfoMapper.selectList(new LambdaQueryWrapper<CoalInfo>().in(CoalInfo::getId, coalIds));

        ProductionMaster master = new ProductionMaster();
        master.setProductionQuantity(totalQuantity);
        master.setTotalCost(totalCost);
        master.setLaborCost(totalLabor);
        master.setEnergyConsumptionCost(totalEnergy);
        master.setEquipmentDepreciation(totalDepreciation);
        master.setCoal(coalInfos.stream().map(CoalInfo::getCoal).collect(Collectors.joining(",")));
        master.setCoalId(coalIds.stream().map(String::valueOf).collect(Collectors.joining(",")));

        return master;
    }

    /**
     * 批量插入生产子表数据
     */
    private void batchInsertProductions(Long masterId, List<Production> list) {
        if (list.isEmpty()) return;

        for (Production p : list) {
            Production copy = new Production();
            BeanUtils.copyProperties(p, copy);
            copy.setId(null);
            copy.setProductionMasterId(masterId);
            productionMapper.insert(copy);
        }
    }

    /**
     * 批量插入库存使用子表数据
     */
    private void batchInsertInventories(Long masterId, List<ProductionInventory> list) {
        if (list.isEmpty()) return;

        for (ProductionInventory p : list) {
            p.setId(null);
            p.setProductionMasterId(masterId);
            productionInventoryMapper.insert(p);
        }
    }

    /**
     * 将加工产生的产品记录到待入库表
     */
    private void insertPendingInventory(List<Production> list) {
        for (Production p : list) {
            PendingInventory pending = new PendingInventory();
            pending.setCoalId(p.getCoalId());
            pending.setInventoryQuantity(p.getProductionQuantity());
            pending.setSupplierName("生产加工入库");
            pending.setTotalPriceIncludingTax(p.getTotalCost());
            pending.setPriceIncludingTax(p.getPurchasePrice());
            pending.setPriceIncludingTax(p.getPurchasePrice());
            pendingInventoryMapper.insert(pending);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int delByIds(Long[] ids) {
        if (ids == null || ids.length == 0) {
            return 0;
        }

        List<Long> idList = Arrays.asList(ids);

        // 1. 预加载所有关联数据
        List<ProductionInventory> allInventoryList = productionInventoryMapper.selectList(
                new LambdaQueryWrapper<ProductionInventory>()
                        .in(ProductionInventory::getProductionMasterId, idList)
        );

        // 2. 按官方库存ID分组并计算库存调整量
        Map<Long, BigDecimal> inventoryAdjustMap = allInventoryList.stream()
                .collect(Collectors.groupingBy(
                        ProductionInventory::getOfficialId,
                        Collectors.reducing(
                                BigDecimal.ZERO,
                                inv -> new BigDecimal(inv.getUsedQuantity()),
                                BigDecimal::add
                        )
                ));

        // 3. 批量更新官方库存 (使用SQL直接更新)
        if (!inventoryAdjustMap.isEmpty()) {
            inventoryAdjustMap.forEach((officialId, adjustAmount) ->
                    officialInventoryMapper.addInventoryQuantity(officialId, adjustAmount)
            );
        }

        // 4. 批量删除关联数据
        if (!allInventoryList.isEmpty()) {
            List<Long> inventoryIds = allInventoryList.stream()
                    .map(ProductionInventory::getId)
                    .collect(Collectors.toList());
            productionInventoryMapper.deleteBatchIds(inventoryIds);
        }

        // 删除生产明细
        productionMapper.delete(
                new LambdaQueryWrapper<Production>()
                        .in(Production::getProductionMasterId, idList)
        );

        // 5. 删除主记录
        return productionMasterMapper.deleteBatchIds(idList);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int deleteProductionInventory(ProductionMasterDto productionMasterDto) {
        List<ProductionInventory> inventories = productionMasterDto.getProductionInventoryList();
        if (CollectionUtils.isEmpty(inventories)) {
            return 0;
        }

        // 预收集数据用于批量操作
        Map<Long, BigDecimal> inventoryAdjustMap = new HashMap<>();
        List<Long> productionIdsToDelete = new ArrayList<>(inventories.size());

        for (ProductionInventory inventory : inventories) {
            // 收集需要删除的生产库存ID
            productionIdsToDelete.add(inventory.getId());

            // 累计库存调整量（相同officialId的用量累加）
            BigDecimal adjustment = new BigDecimal(inventory.getUsedQuantity());
            inventoryAdjustMap.merge(
                    inventory.getOfficialId(),
                    adjustment,
                    BigDecimal::add
            );
        }

        // 批量更新官方库存
        for (Map.Entry<Long, BigDecimal> entry : inventoryAdjustMap.entrySet()) {
            OfficialInventory official = officialInventoryMapper.selectById(entry.getKey());
            if (official == null) {
                throw new BaseException("官方库存不存在，ID: " + entry.getKey());
            }

            // 使用线程安全的BigDecimal操作
            official.setInventoryQuantity(
                    Optional.ofNullable(official.getInventoryQuantity())
                            .orElse(BigDecimal.ZERO)
                            .add(entry.getValue())
            );
            officialInventoryMapper.updateById(official);
        }

        // 批量删除生产库存
        if (!productionIdsToDelete.isEmpty()) {
            productionInventoryMapper.deleteBatchIds(productionIdsToDelete);
        }

        return productionIdsToDelete.size();
    }
}