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.StockUninventoryDto;
import com.ruoyi.stock.execl.StockInRecordExportData;
import com.ruoyi.stock.mapper.StockInRecordMapper;
import com.ruoyi.stock.mapper.StockInventoryMapper;
import com.ruoyi.stock.mapper.StockUninventoryMapper;
import com.ruoyi.stock.pojo.StockInRecord;
import com.ruoyi.stock.pojo.StockInventory;
import com.ruoyi.stock.pojo.StockUninventory;
import com.ruoyi.stock.service.StockInRecordService;
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;

@Service
public class StockInRecordServiceImpl extends ServiceImpl<StockInRecordMapper, StockInRecord> implements StockInRecordService {

    @Autowired
    private StockInRecordMapper stockInRecordMapper;
    @Autowired
    private StockInventoryMapper stockInventoryMapper;
    @Autowired
    private StockUninventoryMapper stockUninventoryMapper;
    @Autowired
    private WeighbridgeDocGenerator weighbridgeDocGenerator;
    @Autowired
    private ProductModelMapper productModelMapper;

    @Override
    public IPage<StockInRecordDto> listPage(Page page, StockInRecordDto stockInRecordDto) {
        return stockInRecordMapper.listPage(page, stockInRecordDto);
    }

    // 新增入库
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int add(StockInRecordDto stockInRecordDto) {
        String no = OrderUtils.countTodayByCreateTime(stockInRecordMapper, "RK");
        stockInRecordDto.setInboundBatches(no);
        StockInRecord stockInRecord = new StockInRecord();
        BeanUtils.copyProperties(stockInRecordDto, stockInRecord);
        return stockInRecordMapper.insert(stockInRecord);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int batchDelete(List<Long> ids) {
        for (Long id : ids) {
            StockInRecord stockInRecord = stockInRecordMapper.selectById(id);
            if (stockInRecord == null) {
                throw new BaseException("入库记录不存在，ID：" + id);
            }

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

            // 获取入库数量及其单位，转换为库存单位
            BigDecimal stockInNum = stockInRecord.getStockInNum();  // 入库记录中存储的数量
            String sourceUnit = stockInRecord.getUnit();  // 入库记录的单位
            String stockUnit = productModel.getUnit();  // 库存单位

            // 将入库数量转换为库存单位
            BigDecimal convertedQuantity = convertQuantityToStockUnit(stockInNum, sourceUnit, stockUnit);

            // 根据入库类型处理不同的库存表
            if ("0".equals(stockInRecord.getType())) {
                // 正常入库，删除时扣减库存
                StockInventory stockInventory = stockInventoryMapper.selectOne(
                        new LambdaQueryWrapper<StockInventory>()
                                .eq(StockInventory::getProductModelId, stockInRecord.getProductModelId())
                );

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

                StockInventoryDto inventoryDto = new StockInventoryDto();
                inventoryDto.setProductModelId(stockInventory.getProductModelId());
                inventoryDto.setQualitity(convertedQuantity);

                // 扣减库存（删除入库记录相当于减少库存）
                int affectedRows = stockInventoryMapper.updateSubtractStockInventory(inventoryDto);
                if (affectedRows == 0) {
                    throw new BaseException("扣减库存失败，库存可能不足");
                }

            } else if ("1".equals(stockInRecord.getType())) {
                // 非正常入库，删除时扣减非正常库存
                StockUninventory stockUninventory = stockUninventoryMapper.selectOne(
                        new LambdaQueryWrapper<StockUninventory>()
                                .eq(StockUninventory::getProductModelId, stockInRecord.getProductModelId())
                );

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

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

                // 扣减非正常库存
                int affectedRows = stockUninventoryMapper.updateSubtractStockUnInventory(uninventoryDto);
                if (affectedRows == 0) {
                    throw new BaseException("扣减非正常库存失败");
                }
            }
        }

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

    @Override
    public void exportStockInRecord(HttpServletResponse response, StockInRecordDto stockInRecordDto) {
        List<StockInRecordExportData> list = stockInRecordMapper.listStockInRecordExportData(stockInRecordDto);
        for (StockInRecordExportData 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<StockInRecordExportData> util = new ExcelUtil<>(StockInRecordExportData.class);
        util.exportExcel(response,list, "入库记录信息");
    }

    @Override
    public int editStockInStock(StockInRecordDto stockInRecordDto) {
        if (stockInRecordDto.getId() == null) {
            throw new BaseException("入库记录ID不能为空");
        }

        // 1. 查询原始入库记录
        StockInRecord originalRecord = stockInRecordMapper.selectById(stockInRecordDto.getId());
        if (originalRecord == null) {
            throw new BaseException("入库记录不存在");
        }

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

        // 3. 获取原始入库数量及其单位
        BigDecimal originalNetWeight = originalRecord.getStockInNum();  // 原始记录中存储的数量
        String originalUnit = originalRecord.getUnit();  // 原始记录的单位
        String stockUnit = productModel.getUnit();  // 库存单位

        // 将原始入库数量转换为库存单位
        BigDecimal originalNetWeightInStockUnit = convertQuantityToStockUnit(originalNetWeight, originalUnit, stockUnit);

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

        // 将新入库数量转换为库存单位
        BigDecimal newNetWeightInStockUnit = convertQuantityToStockUnit(newNetWeight, newUnit, stockUnit);

        // 5. 计算库存变化量（使用统一转换后的库存单位值）
        // 入库数量变化量（正数表示入库变多，需要增加库存；负数表示入库变少，需要减少库存）
        BigDecimal diffQuantity = newNetWeightInStockUnit.subtract(originalNetWeightInStockUnit);

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

        // 7. 生成磅单
        String absoluteDocPath = weighbridgeDocGenerator.generateWeighbridgeDoc(stockInRecordDto);
        stockInRecordDto.setWeighbridgeDocPath(absoluteDocPath);
        int updateResult = stockInRecordMapper.updateById(stockInRecordDto);

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

        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 diffQuantity 库存变化量（正数为增加，负数为减少）
     */
    private void updateInventory(Long productId, BigDecimal diffQuantity) {
        // 查询当前库存
        StockInventory stockInventory = stockInventoryMapper.selectOne(
                new QueryWrapper<StockInventory>().lambda()
                        .eq(StockInventory::getProductId, productId)
        );

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

        StockInventoryDto inventoryDto = new StockInventoryDto();
        BeanUtils.copyProperties(stockInventory, inventoryDto);
        inventoryDto.setQualitity(diffQuantity.abs());

        // 根据变化量正负调用不同的更新方法
        if (diffQuantity.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("库存不足，无法扣减");
            }
        }
    }
}