package com.designhub.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.designhub.entity.*;
import com.designhub.mapper.*;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 配置管理Service
 */
@Service
@RequiredArgsConstructor
public class ConfigService {

    private final DemandTypeMapper demandTypeMapper;
    private final BrandMapper brandMapper;
    private final PlatformMapper platformMapper;
    private final CategoryMapper categoryMapper;

    // ============ 需求类型管理 ============

    /**
     * 获取所有需求类型（包括禁用的，用于管理页面）- 平铺列表
     */
    public List<DemandType> getAllDemandTypes() {
        List<DemandType> list = demandTypeMapper.selectList(
            new LambdaQueryWrapper<DemandType>()
                .orderByAsc(DemandType::getParentId)
                .orderByAsc(DemandType::getSortOrder)
        );
        // 填充父分类名称
        for (DemandType dt : list) {
            if (dt.getParentId() != null) {
                DemandType parent = demandTypeMapper.selectById(dt.getParentId());
                if (parent != null) {
                    dt.setParentName(parent.getName());
                }
            }
        }
        return list;
    }

    /**
     * 获取所有需求类型（树形结构）
     */
    public List<DemandType> getDemandTypesTree() {
        List<DemandType> allTypes = demandTypeMapper.selectList(
            new LambdaQueryWrapper<DemandType>()
                .orderByAsc(DemandType::getSortOrder)
        );
        // 构建树形结构
        return buildDemandTypeTree(allTypes);
    }

    /**
     * 获取所有大分类（parentId为null的）
     */
    public List<DemandType> getParentDemandTypes() {
        return demandTypeMapper.selectList(
            new LambdaQueryWrapper<DemandType>()
                .isNull(DemandType::getParentId)
                .orderByAsc(DemandType::getSortOrder)
        );
    }

    /**
     * 根据父ID获取子分类
     */
    public List<DemandType> getDemandTypesByParentId(Long parentId) {
        return demandTypeMapper.selectList(
            new LambdaQueryWrapper<DemandType>()
                .eq(DemandType::getParentId, parentId)
                .orderByAsc(DemandType::getSortOrder)
        );
    }
    
    /**
     * 获取所有启用的需求类型（用于下拉选择）- 树形结构
     */
    public List<DemandType> getEnabledDemandTypes() {
        List<DemandType> allTypes = demandTypeMapper.selectList(
            new LambdaQueryWrapper<DemandType>()
                .eq(DemandType::getIsEnabled, 1)
                .orderByAsc(DemandType::getSortOrder)
        );
        return buildDemandTypeTree(allTypes);
    }

    /**
     * 获取所有启用的需求类型（平铺列表，用于表单选择）
     */
    public List<DemandType> getEnabledDemandTypesList() {
        List<DemandType> list = demandTypeMapper.selectList(
            new LambdaQueryWrapper<DemandType>()
                .eq(DemandType::getIsEnabled, 1)
                .orderByAsc(DemandType::getParentId)
                .orderByAsc(DemandType::getSortOrder)
        );
        // 填充父分类名称
        for (DemandType dt : list) {
            if (dt.getParentId() != null) {
                DemandType parent = demandTypeMapper.selectById(dt.getParentId());
                if (parent != null) {
                    dt.setParentName(parent.getName());
                }
            }
        }
        return list;
    }

    /**
     * 构建需求类型树形结构
     */
    private List<DemandType> buildDemandTypeTree(List<DemandType> allTypes) {
        // 获取所有根节点（parentId为null）
        List<DemandType> roots = allTypes.stream()
            .filter(dt -> dt.getParentId() == null)
            .collect(java.util.stream.Collectors.toList());
        
        // 为每个根节点填充子节点
        for (DemandType root : roots) {
            List<DemandType> children = allTypes.stream()
                .filter(dt -> root.getId().equals(dt.getParentId()))
                .collect(java.util.stream.Collectors.toList());
            root.setChildren(children);
        }
        
        return roots;
    }

    /**
     * 根据ID获取需求类型
     */
    public DemandType getDemandTypeById(Long id) {
        DemandType dt = demandTypeMapper.selectById(id);
        if (dt != null && dt.getParentId() != null) {
            DemandType parent = demandTypeMapper.selectById(dt.getParentId());
            if (parent != null) {
                dt.setParentName(parent.getName());
            }
        }
        return dt;
    }

    /**
     * 创建需求类型
     */
    public DemandType createDemandType(DemandType demandType) {
        demandTypeMapper.insert(demandType);
        return demandType;
    }

    /**
     * 更新需求类型
     */
    public boolean updateDemandType(DemandType demandType) {
        return demandTypeMapper.updateById(demandType) > 0;
    }

    /**
     * 删除需求类型（如果是大分类，同时删除所有子分类）
     */
    public boolean deleteDemandType(Long id) {
        // 先删除所有子分类
        demandTypeMapper.delete(
            new LambdaQueryWrapper<DemandType>()
                .eq(DemandType::getParentId, id)
        );
        // 再删除自身
        return demandTypeMapper.deleteById(id) > 0;
    }

    // ============ 品牌管理 ============

    /**
     * 获取所有品牌（包括禁用的，用于管理页面）
     */
    public List<Brand> getAllBrands() {
        return brandMapper.selectList(
            new LambdaQueryWrapper<Brand>()
                .orderByAsc(Brand::getSortOrder)
        );
    }
    
    /**
     * 获取所有启用的品牌（用于下拉选择）
     */
    public List<Brand> getEnabledBrands() {
        return brandMapper.selectList(
            new LambdaQueryWrapper<Brand>()
                .eq(Brand::getIsEnabled, 1)
                .orderByAsc(Brand::getSortOrder)
        );
    }

    /**
     * 根据ID获取品牌
     */
    public Brand getBrandById(Long id) {
        return brandMapper.selectById(id);
    }

    /**
     * 创建品牌
     */
    public Brand createBrand(Brand brand) {
        brandMapper.insert(brand);
        return brand;
    }

    /**
     * 更新品牌
     */
    public boolean updateBrand(Brand brand) {
        return brandMapper.updateById(brand) > 0;
    }

    /**
     * 删除品牌
     */
    public boolean deleteBrand(Long id) {
        return brandMapper.deleteById(id) > 0;
    }

    // ============ 平台管理 ============

    /**
     * 获取所有平台（包括禁用的，用于管理页面）
     */
    public List<Platform> getAllPlatforms() {
        return platformMapper.selectList(
            new LambdaQueryWrapper<Platform>()
                .orderByAsc(Platform::getSortOrder)
        );
    }
    
    /**
     * 获取所有启用的平台（用于下拉选择）
     */
    public List<Platform> getEnabledPlatforms() {
        return platformMapper.selectList(
            new LambdaQueryWrapper<Platform>()
                .eq(Platform::getIsEnabled, 1)
                .orderByAsc(Platform::getSortOrder)
        );
    }

    /**
     * 根据ID获取平台
     */
    public Platform getPlatformById(Long id) {
        return platformMapper.selectById(id);
    }

    /**
     * 创建平台
     */
    public Platform createPlatform(Platform platform) {
        platformMapper.insert(platform);
        return platform;
    }

    /**
     * 更新平台
     */
    public boolean updatePlatform(Platform platform) {
        return platformMapper.updateById(platform) > 0;
    }

    /**
     * 删除平台
     */
    public boolean deletePlatform(Long id) {
        return platformMapper.deleteById(id) > 0;
    }

    // ============ 类目管理 ============

    /**
     * 获取所有叶子类目（包括禁用的，用于管理页面）
     */
    public List<Category> getAllLeafCategories() {
        return categoryMapper.selectList(
            new LambdaQueryWrapper<Category>()
                .eq(Category::getIsLeaf, 1)
                .orderByAsc(Category::getSortOrder)
        );
    }

    /**
     * 获取所有类目（包括禁用的，用于管理页面）
     */
    public List<Category> getAllCategories() {
        return categoryMapper.selectList(
            new LambdaQueryWrapper<Category>()
                .orderByAsc(Category::getSortOrder)
        );
    }
    
    /**
     * 获取所有启用的类目（树形结构）
     */
    public List<Category> getEnabledCategories() {
        return categoryMapper.selectList(
            new LambdaQueryWrapper<Category>()
                .eq(Category::getIsEnabled, 1)
                .orderByAsc(Category::getSortOrder)
        );
    }
    
    /**
     * 获取所有启用的叶子类目（用于下拉选择）
     */
    public List<Category> getEnabledLeafCategories() {
        return categoryMapper.selectList(
            new LambdaQueryWrapper<Category>()
                .eq(Category::getIsEnabled, 1)
                .eq(Category::getIsLeaf, 1)
                .orderByAsc(Category::getSortOrder)
        );
    }

    /**
     * 根据父ID获取子类目
     */
    public List<Category> getCategoriesByParentId(Long parentId) {
        return categoryMapper.selectList(
            new LambdaQueryWrapper<Category>()
                .eq(Category::getParentId, parentId)
                .eq(Category::getIsEnabled, 1)
                .orderByAsc(Category::getSortOrder)
        );
    }

    /**
     * 根据ID获取类目
     */
    public Category getCategoryById(Long id) {
        return categoryMapper.selectById(id);
    }

    /**
     * 创建类目
     */
    public Category createCategory(Category category) {
        categoryMapper.insert(category);
        return category;
    }

    /**
     * 更新类目
     */
    public boolean updateCategory(Category category) {
        return categoryMapper.updateById(category) > 0;
    }

    /**
     * 删除类目
     */
    public boolean deleteCategory(Long id) {
        return categoryMapper.deleteById(id) > 0;
    }
}