package com.ruoyi.basic.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.basic.dto.ProductDto;
import com.ruoyi.basic.dto.ProductTreeDto;
import com.ruoyi.basic.mapper.ProductMapper;
import com.ruoyi.basic.mapper.ProductModelMapper;
import com.ruoyi.basic.pojo.Product;
import com.ruoyi.basic.pojo.ProductModel;
import com.ruoyi.basic.service.IProductService;
import com.ruoyi.basic.vo.ProductModelVo;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.bean.BeanUtils;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@Service
@AllArgsConstructor
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements IProductService {

    private ProductMapper productMapper;

    private ProductModelMapper productModelMapper;

    @Override
    public List<ProductTreeDto> selectProductList(ProductDto productDto) {
        // 查询根节点（parentId 为 null）
        LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.isNull(Product::getParentId);

        // 如果有产品名称条件，添加到查询中
        if (productDto.getProductName() != null && !productDto.getProductName().isEmpty()) {
            queryWrapper.like(Product::getProductName, productDto.getProductName());
        }

        // 查询根节点列表
        List<Product> rootProducts = productMapper.selectList(queryWrapper);

        // 转换为树节点并递归构建子树
        List<ProductTreeDto> tree = new ArrayList<>();
        for (Product product : rootProducts) {
            ProductTreeDto node = convertToTreeDto(product);
            node.setChildren(buildChildrenNodes(product.getId()));
            tree.add(node);
        }
        return tree;
    }

    @Override
    public IPage<ProductModelVo> listPageProductModel(Page<ProductModelVo> page, ProductModel productModel) {
        return productModelMapper.listPageProductModel(page, productModel);
    }


    // 递归构建子节点
    private List<ProductTreeDto> buildChildrenNodes(Long parentId) {
        // 查询当前父节点的子节点
        LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Product::getParentId, parentId);
        List<Product> childProducts = productMapper.selectList(queryWrapper);

        // 转换子节点并递归构建它们的子树
        List<ProductTreeDto> children = new ArrayList<>();
        for (Product child : childProducts) {
            ProductTreeDto childNode = convertToTreeDto(child);
            childNode.setChildren(buildChildrenNodes(child.getId()));
            children.add(childNode);
        }

        return children;
    }

    // 将 Product 转换为 ProductTreeDto
    private ProductTreeDto convertToTreeDto(Product product) {
        ProductTreeDto dto = new ProductTreeDto();
        BeanUtils.copyProperties(product, dto);
        dto.setLabel(product.getProductName()); // 设置 label 为产品名称
        dto.setChildren(new ArrayList<>());
        return dto;
    }

    @Override
    public int addOrEditProduct(ProductDto productDto) {
        String productName = StringUtils.trim(productDto.getProductName());
        if (StringUtils.isEmpty(productName)) {
            throw new IllegalArgumentException("产品名称不能为空");
        }
        // 父节点为空表示新增一级大类
        if (ObjectUtils.isEmpty(productDto.getParentId())) {
            if (productDto.getId() != null) {
                throw new IllegalArgumentException("请选择父节点");
            }
            productDto.setParentId(null);
        }
        productDto.setProductName(productName);
        checkProductNameUnique(productDto.getParentId(), productName, productDto.getId());
        if (productDto.getId() == null) {
            // 新增产品逻辑
            // 检查父节点是否存在（一级大类无父节点）
            if (productDto.getParentId() != null) {
                Product parent = productMapper.selectById(productDto.getParentId());
                if (parent == null) {
                    throw new IllegalArgumentException("父节点不存在，无法添加子产品");
                }
            }
            return productMapper.insert(productDto);
        } else {
            // 编辑产品逻辑
            // 检查产品是否存在（可选，根据业务需求）
            Product existingProduct = productMapper.selectById(productDto.getId());
            if (existingProduct == null) {
                throw new IllegalArgumentException("要编辑的产品不存在");
            }
            return productMapper.updateById(productDto);
        }
    }

    private void checkProductNameUnique(Long parentId, String productName, Long currentId) {
        LambdaQueryWrapper<Product> queryWrapper = new LambdaQueryWrapper<>();
        if (parentId == null) {
            queryWrapper.isNull(Product::getParentId);
        } else {
            queryWrapper.eq(Product::getParentId, parentId);
        }
        queryWrapper.eq(Product::getProductName, productName)
                .ne(currentId != null, Product::getId, currentId)
                .last("limit 1");
        Product duplicateProduct = productMapper.selectOne(queryWrapper);
        if (duplicateProduct != null) {
            throw new IllegalArgumentException("对应的" + productName + "已经存在");
        }
    }

    @Override
    public int delProductByIds(Long[] ids) {
        // 存在子类时不允许删除
        LambdaQueryWrapper<Product> childWrapper = new LambdaQueryWrapper<>();
        childWrapper.in(Product::getParentId, ids).last("limit 1");
        Product childProduct = productMapper.selectOne(childWrapper);
        if (childProduct != null) {
            throw new IllegalArgumentException("该大类下存在子类，不能删除");
        }

        // 大类下存在规格型号数据时不允许删除
        for (Product product : productMapper.selectBatchIds(Arrays.asList(ids))) {
            if (product.getParentId() != null) {
                continue;
            }
            LambdaQueryWrapper<ProductModel> modelWrapper = new LambdaQueryWrapper<>();
            modelWrapper.eq(ProductModel::getProductId, product.getId()).last("limit 1");
            if (productModelMapper.selectOne(modelWrapper) != null) {
                throw new IllegalArgumentException("该大类下存在数据，不能删除");
            }
        }

        // 1. 删除子表 product_model 中关联的数据
        LambdaQueryWrapper<ProductModel> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(ProductModel::getProductId, ids);
        productModelMapper.delete(queryWrapper);

        // 2. 删除主表 product 数据
        int deleteCount = productMapper.deleteBatchIds(Arrays.asList(ids));

        return deleteCount;
    }

    /** 台账手工录入的产品大类/规格型号统一挂到这个大类下 */
    private static final String TOP_CATEGORY_NAME = "成品";

    @Override
    public ProductModel ensureProductHierarchy(String productName, String modelName, String unit) {
        productName = StringUtils.trim(productName);
        modelName = StringUtils.trim(modelName);
        if (StringUtils.isEmpty(productName) || StringUtils.isEmpty(modelName)) {
            return null;
        }

        // 一级大类：固定「成品」（不存在则建）
        LambdaQueryWrapper<Product> categoryWrapper = new LambdaQueryWrapper<>();
        categoryWrapper.isNull(Product::getParentId)
                .eq(Product::getProductName, TOP_CATEGORY_NAME)
                .last("limit 1");
        Product category = productMapper.selectOne(categoryWrapper);
        if (category == null) {
            category = new Product();
            category.setProductName(TOP_CATEGORY_NAME);
            productMapper.insert(category);
        }

        // 二级：产品大类（成品下的子类）
        LambdaQueryWrapper<Product> nameWrapper = new LambdaQueryWrapper<>();
        nameWrapper.eq(Product::getParentId, category.getId())
                .eq(Product::getProductName, productName)
                .last("limit 1");
        Product nameProduct = productMapper.selectOne(nameWrapper);
        if (nameProduct == null) {
            nameProduct = new Product();
            nameProduct.setParentId(category.getId());
            nameProduct.setProductName(productName);
            productMapper.insert(nameProduct);
        }

        // 三级：规格型号（产品大类下的规格）
        LambdaQueryWrapper<ProductModel> modelWrapper = new LambdaQueryWrapper<>();
        modelWrapper.eq(ProductModel::getProductId, nameProduct.getId())
                .eq(ProductModel::getModel, modelName)
                .last("limit 1");
        ProductModel productModel = productModelMapper.selectOne(modelWrapper);
        if (productModel == null) {
            productModel = new ProductModel();
            productModel.setProductId(nameProduct.getId());
            productModel.setModel(modelName);
            productModel.setUnit(unit);
            productModelMapper.insert(productModel);
        }
        return productModel;
    }

}