package com.ruoyi.stock.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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.basic.mapper.ProductModelMapper;
import com.ruoyi.basic.pojo.ProductModel;
import com.ruoyi.common.enums.StockInUnQualifiedRecordTypeEnum;
import com.ruoyi.common.enums.StockOutQualifiedRecordTypeEnum;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.EnumUtil;
import com.ruoyi.common.utils.OrderUtils;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.stock.dto.StockInRecordDto;
import com.ruoyi.stock.dto.StockInventoryDto;
import com.ruoyi.stock.dto.StockOutRecordDto;
import com.ruoyi.stock.dto.StockUninventoryDto;
import com.ruoyi.stock.execl.StockOutRecordExportData;
import com.ruoyi.stock.mapper.StockInventoryMapper;
import com.ruoyi.stock.mapper.StockOutRecordMapper;
import com.ruoyi.stock.mapper.StockUninventoryMapper;
import com.ruoyi.stock.pojo.StockInventory;
import com.ruoyi.stock.pojo.StockOutRecord;
import com.ruoyi.stock.pojo.StockUninventory;
import com.ruoyi.stock.service.StockOutRecordService;
import com.ruoyi.stock.word.WeighbridgeDocGenerator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.http.HttpServletResponse;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.List;

/**
 * <p>
 * 出库记录表 服务实现类
 * </p>
 *
 * @author 芯导软件（江苏）有限公司
 * @since 2026-01-21 05:27:04
 */
@Service
public class StockOutRecordServiceImpl extends ServiceImpl<StockOutRecordMapper, StockOutRecord> implements StockOutRecordService {
    @Autowired
    private StockOutRecordMapper stockOutRecordMapper;
    @Autowired
    private StockInventoryMapper stockInventoryMapper;
    @Autowired
    private StockUninventoryMapper stockUninventoryMapper;
    @Autowired
    private WeighbridgeDocGenerator weighbridgeDocGenerator;
    @Autowired
    private ProductModelMapper productModelMapper;

    @Override
    public IPage<StockOutRecordDto> listPage(Page page, StockOutRecordDto stockOutRecordDto) {
        return stockOutRecordMapper.listPage(page, stockOutRecordDto);
    }

    @Override
    public int add(StockOutRecordDto stockOutRecordDto) {
        String no = OrderUtils.countTodayByCreateTime(stockOutRecordMapper, "CK");
        stockOutRecordDto.setOutboundBatches(no);
        return stockOutRecordMapper.insert(stockOutRecordDto);
    }

    @Override
    public int update(Long id, StockOutRecordDto stockOutRecordDto) {
        // 判断对象是否存在
        StockOutRecord stockOutRecord = stockOutRecordMapper.selectById(id);
        if (stockOutRecord == null) {
            throw new BaseException("该出库记录不存在,无法更新!!!");
        }

        String[] ignoreProperties = {"id", "outbound_batches"};//排除id属性
        BeanUtils.copyProperties(stockOutRecordDto, stockOutRecord, ignoreProperties);
        return stockOutRecordMapper.updateById(stockOutRecord);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int batchDelete(List<Long> ids) {
        for (Long id : ids) {
            // 1. 查询出库记录
            StockOutRecord stockOutRecord = stockOutRecordMapper.selectById(id);
            if (stockOutRecord == null) {
                throw new BaseException("出库记录不存在，ID：" + id);
            }

            // 2. 查询产品型号（用于单位转换）
            ProductModel productModel = productModelMapper.selectById(stockOutRecord.getProductModelId());
            if (productModel == null) {
                throw new BaseException("产品型号不存在，无法删除");
            }

            // 3. 获取出库数量并进行单位转换
            BigDecimal stockOutNum = stockOutRecord.getStockOutNum();
            String sourceUnit = stockOutRecord.getUnit(); // 出库记录中保存的单位
            String targetUnit = productModel.getUnit();

            // 转换出库数量为库存单位（删除时需要加回库存，所以需要转换）
            BigDecimal convertedQuantity = convertQuantityToStockUnit(stockOutNum, sourceUnit, targetUnit);

            // 4. 根据出库类型处理不同的库存表
            if ("0".equals(stockOutRecord.getType())) {
                // 正常出库，恢复库存
                StockInventory stockInventory = stockInventoryMapper.selectOne(
                        new LambdaQueryWrapper<StockInventory>()
                                .eq(StockInventory::getProductModelId, stockOutRecord.getProductModelId())
                );

                if (stockInventory == null) {
                    throw new BaseException("库存记录中没有对应的产品，无法删除");
                }

                // 创建库存更新DTO
                StockInventoryDto inventoryDto = new StockInventoryDto();
                inventoryDto.setProductModelId(stockInventory.getProductModelId());
                inventoryDto.setQualitity(convertedQuantity);

                // 加回库存
                int affectedRows = stockInventoryMapper.updateAddStockInventory(inventoryDto);
                if (affectedRows == 0) {
                    throw new BaseException("恢复库存失败");
                }

            } else if ("1".equals(stockOutRecord.getType())) {
                // 非正常出库，恢复非正常库存
                StockUninventory stockUninventory = stockUninventoryMapper.selectOne(
                        new LambdaQueryWrapper<StockUninventory>()
                                .eq(StockUninventory::getProductModelId, stockOutRecord.getProductModelId())
                );

                if (stockUninventory == null) {
                    throw new BaseException("非正常库存记录中没有对应的产品，无法删除");
                }

                // 创建非正常库存更新DTO
                StockUninventoryDto uninventoryDto = new StockUninventoryDto();
                uninventoryDto.setProductModelId(stockUninventory.getProductModelId());
                uninventoryDto.setQualitity(convertedQuantity);

                // 加回非正常库存
                int affectedRows = stockUninventoryMapper.updateAddStockUnInventory(uninventoryDto);
                if (affectedRows == 0) {
                    throw new BaseException("恢复非正常库存失败");
                }
            }
        }

        // 5. 批量删除出库记录
        return stockOutRecordMapper.deleteBatchIds(ids);
    }

    @Override
    public void exportStockOutRecord(HttpServletResponse response, StockOutRecordDto stockOutRecordDto) {
        List<StockOutRecordExportData> list = stockOutRecordMapper.listStockOutRecordExportData(stockOutRecordDto);
        for (StockOutRecordExportData stockInRecordExportData : list) {
            if (stockInRecordExportData.getType().equals("0")) {
                stockInRecordExportData.setRecordType(EnumUtil.fromCode(StockOutQualifiedRecordTypeEnum.class, Integer.parseInt(stockInRecordExportData.getRecordType())).getValue());
            } else {
                stockInRecordExportData.setRecordType(EnumUtil.fromCode(StockInUnQualifiedRecordTypeEnum.class, Integer.parseInt(stockInRecordExportData.getRecordType())).getValue());
            }
        }
        ExcelUtil<StockOutRecordExportData> util = new ExcelUtil<>(StockOutRecordExportData.class);
        util.exportExcel(response, list, "出库记录信息");
    }

    @Override
    public int editStockOut(StockOutRecordDto stockOutRecordDto) {
        if (stockOutRecordDto.getId() == null) {
            throw new BaseException("出库记录ID不能为空");
        }

        // 1. 查询原始出库记录
        StockOutRecord originalRecord = stockOutRecordMapper.selectById(stockOutRecordDto.getId());
        if (originalRecord == null) {
            throw new BaseException("出库记录不存在");
        }

        // 2. 查询产品型号信息（用于单位转换）
        ProductModel productModel = productModelMapper.selectById(originalRecord.getProductModelId());
        if (productModel == null) {
            throw new BaseException("产品型号不存在");
        }

        // 3. 获取原始出库数量及其单位
        BigDecimal originalOutNum = originalRecord.getStockOutNum();  // 原始记录中存储的数量（可能是吨或公斤）
        String originalUnit = originalRecord.getUnit();  // 原始记录的单位（吨、公斤等）
        String stockUnit = productModel.getUnit();  // 库存单位

        // 将原始出库数量转换为库存单位
        BigDecimal originalOutNumInStockUnit = convertQuantityToStockUnit(originalOutNum, originalUnit, stockUnit);

        // 4. 获取新出库数量及其单位
        BigDecimal newOutNum = stockOutRecordDto.getNetWeight();  // 新输入的数量
        if (newOutNum == null) {
            throw new BaseException("出库数量不能为空");
        }
        String newUnit = stockOutRecordDto.getUnit();  // 新输入的单位

        // 将新出库数量转换为库存单位
        BigDecimal newOutNumInStockUnit = convertQuantityToStockUnit(newOutNum, newUnit, stockUnit);

        // 5. 计算库存变化量（使用统一转换后的库存单位值）
        // 出库数量变化量（正数表示出库变多，需要多扣库存；负数表示出库变少，需要加回库存）
        BigDecimal diffQuantity = newOutNumInStockUnit.subtract(originalOutNumInStockUnit);
        // 转换为库存变化量：出库变多（diffQuantity > 0）时，库存减少；出库变少（diffQuantity < 0）时，库存增加
        BigDecimal inventoryChange = diffQuantity.negate();

        // 6. 更新出库记录（保存用户输入的原始数值和单位）
        stockOutRecordDto.setStockOutNum(stockOutRecordDto.getNetWeight());  // 保存用户输入的值
        stockOutRecordDto.setUnit(stockOutRecordDto.getUnit());  // 保存用户输入的单位

        // 7. 生成磅单
        StockInRecordDto stockInRecordDto = new StockInRecordDto();
        BeanUtils.copyProperties(stockOutRecordDto, stockInRecordDto);
        stockInRecordDto.setStockInNum(stockOutRecordDto.getStockOutNum());
        String absoluteDocPath = weighbridgeDocGenerator.generateWeighbridgeDoc(stockInRecordDto);
        stockOutRecordDto.setWeighbridgeDocPath(absoluteDocPath);
        int updateResult = stockOutRecordMapper.updateById(stockOutRecordDto);

        // 8. 更新库存（仅在数量发生变化时）
        if (inventoryChange.compareTo(BigDecimal.ZERO) != 0) {
            updateInventoryForStockOut(stockOutRecordDto.getProductId(), inventoryChange);
        }

        return updateResult;
    }

    /**
     * 将数量转换为库存单位
     *
     * @param quantity   原始数量
     * @param sourceUnit 原始单位
     * @param targetUnit 目标单位（库存单位）
     * @return 转换后的数量
     */
    private BigDecimal convertQuantityToStockUnit(BigDecimal quantity, String sourceUnit, String targetUnit) {
        if (quantity == null) {
            throw new BaseException("数量不能为空");
        }

        // 如果源单位为空，直接返回原值
        if (sourceUnit == null || sourceUnit.isEmpty()) {
            return quantity;
        }

        // 如果源单位和目标单位相同，直接返回
        if (sourceUnit.equals(targetUnit)) {
            return quantity;
        }

        // 单位转换
        if ("吨".equals(targetUnit)) {
            // 目标单位是吨，需要将源单位转换为吨
            if ("公斤".equals(sourceUnit)) {
                // 公斤转吨：除以1000
                return quantity.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_UP);
            } else if ("克".equals(sourceUnit)) {
                // 克转吨：除以1000000
                return quantity.divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP);
            }
        } else if ("公斤".equals(targetUnit)) {
            // 目标单位是公斤
            if ("吨".equals(sourceUnit)) {
                // 吨转公斤：乘以1000
                return quantity.multiply(BigDecimal.valueOf(1000));
            } else if ("克".equals(sourceUnit)) {
                // 克转公斤：除以1000
                return quantity.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_UP);
            }
        } else if ("克".equals(targetUnit)) {
            // 目标单位是克
            if ("吨".equals(sourceUnit)) {
                // 吨转克：乘以1000000
                return quantity.multiply(BigDecimal.valueOf(1000000));
            } else if ("公斤".equals(sourceUnit)) {
                // 公斤转克：乘以1000
                return quantity.multiply(BigDecimal.valueOf(1000));
            }
        }

        // 无法转换时返回原值
        return quantity;
    }

    /**
     * 更新库存（出库场景）
     *
     * @param productId       产品ID
     * @param inventoryChange 库存变化量（正数为增加库存，负数为减少库存）
     */
    private void updateInventoryForStockOut(Long productId, BigDecimal inventoryChange) {
        // 查询当前库存
        StockInventory stockInventory = stockInventoryMapper.selectOne(
                new QueryWrapper<StockInventory>().lambda()
                        .eq(StockInventory::getProductId, productId)
        );

        if (stockInventory == null) {
            throw new BaseException("库存记录不存在");
        }

        // 创建库存更新DTO
        StockInventoryDto inventoryDto = new StockInventoryDto();
        BeanUtils.copyProperties(stockInventory, inventoryDto);
        inventoryDto.setQualitity(inventoryChange.abs());

        // 根据库存变化量调用不同的更新方法
        if (inventoryChange.compareTo(BigDecimal.ZERO) > 0) {
            // 库存增加（出库数量变少，需要加回库存）
            int affectedRows = stockInventoryMapper.updateAddStockInventory(inventoryDto);
            if (affectedRows == 0) {
                throw new BaseException("更新库存失败");
            }
        } else {
            // 库存减少（出库数量变多，需要多扣库存）
            int affectedRows = stockInventoryMapper.updateSubtractStockInventory(inventoryDto);
            if (affectedRows == 0) {
                throw new BaseException("库存不足，无法扣减");
            }
        }
    }
}