package com.designhub.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.designhub.dto.DepartmentCreateRequest;
import com.designhub.dto.DepartmentLimitSettingsRequest;
import com.designhub.dto.DepartmentScoreAdjustRequest;
import com.designhub.dto.DepartmentUpdateRequest;
import com.designhub.entity.Brand;
import com.designhub.entity.Department;
import com.designhub.entity.DeptBrandRelation;
import com.designhub.entity.User;
import com.designhub.exception.BusinessException;
import com.designhub.mapper.BrandMapper;
import com.designhub.mapper.DepartmentMapper;
import com.designhub.mapper.DeptBrandRelationMapper;
import com.designhub.mapper.UserMapper;
import com.designhub.vo.DepartmentOverviewVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 部门管理Service
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class DepartmentService {

    private final DepartmentMapper departmentMapper;
    private final TeamScorePoolService teamScorePoolService;
    private final UserMapper userMapper;
    private final DeptBrandRelationMapper deptBrandRelationMapper;
    private final BrandMapper brandMapper;

    /**
     * 获取所有部门列表
     */
    public List<Department> getAllDepartments() {
        return departmentMapper.selectList(
            new LambdaQueryWrapper<Department>()
                .eq(Department::getStatus, 1)
                .orderByAsc(Department::getSortOrder)
        );
    }

    /**
     * 获取部门树形结构
     */
    public List<Department> getDepartmentTree() {
        List<Department> allDepts = departmentMapper.selectDeptTree();
        return buildTree(allDepts, 0L);
    }

    /**
     * 根据类型获取部门列表
     */
    public List<Department> getDepartmentsByType(String deptType) {
        return departmentMapper.selectList(
            new LambdaQueryWrapper<Department>()
                .eq(Department::getDeptType, deptType)
                .eq(Department::getStatus, 1)
                .orderByAsc(Department::getSortOrder)
        );
    }

    /**
     * 根据ID获取部门
     */
    public Department getDepartmentById(Long id) {
        return departmentMapper.selectById(id);
    }

    /**
     * 部门概览列表
     */
    public List<DepartmentOverviewVO> getDepartmentOverviewList() {
        List<Department> departments = getAllDepartments();
        Map<Long, Long> memberCountMap = loadMemberCountMap();
        Map<Long, String> leaderNameMap = loadLeaderNames(departments);
        return departments.stream()
            .map(dept -> buildOverviewVO(dept, memberCountMap, leaderNameMap))
            .collect(Collectors.toList());
    }

    /**
     * 获取单个部门概览
     */
    public DepartmentOverviewVO getDepartmentOverview(Long deptId) {
        Department department = getDepartmentById(deptId);
        if (department == null) {
            throw new BusinessException("部门不存在");
        }
        Map<Long, Long> memberCountMap = loadMemberCountMap();
        Map<Long, String> leaderNameMap = loadLeaderNames(Collections.singletonList(department));
        return buildOverviewVO(department, memberCountMap, leaderNameMap);
    }

    /**
     * 创建部门
     */
    @Transactional(rollbackFor = Exception.class)
    public DepartmentOverviewVO createDepartment(DepartmentCreateRequest request) {
        validateDeptType(request.getDeptType());

        // 验证负责人ID是否有效
        if (request.getLeaderId() != null && request.getLeaderId() > 0) {
            User leader = userMapper.selectById(request.getLeaderId());
            if (leader == null) {
                throw new BusinessException("指定的负责人不存在");
            }
        }

        Department department = new Department();
        department.setDeptName(request.getDeptName());
        department.setDeptCode(request.getDeptCode());
        department.setDeptType(request.getDeptType());
        department.setParentId(request.getParentId() != null ? request.getParentId() : 0L);
        department.setLeaderId(request.getLeaderId());
        department.setSortOrder(request.getSortOrder());
        department.setStatus(request.getStatus());
        department.setAllowedDemandTypes(joinAllowedTypes(request.getAllowedDemandTypes()));

        departmentMapper.insert(department);

        // 初始化积分池（需求部门和一级需求部门都需要积分池）
        teamScorePoolService.upsertPool(department.getId(), department.getDeptName());
        if ("demand".equals(request.getDeptType()) || "primary_demand".equals(request.getDeptType())) {
            if (request.getInitialScoreBalance() != null) {
                teamScorePoolService.setBalance(department.getId(), request.getInitialScoreBalance());
                department.setScoreBalance(request.getInitialScoreBalance());
            }
            teamScorePoolService.updateLimitConfig(
                department.getId(),
                defaultLimitEnabled(request.getLimitEnabled()),
                defaultLimitPeriod(request.getLimitPeriod()),
                request.getPeriodLimit(),
                request.getAlertThreshold()
            );
            department.setLimitEnabled(defaultLimitEnabled(request.getLimitEnabled()));
            department.setLimitPeriod(defaultLimitPeriod(request.getLimitPeriod()));
            department.setPeriodLimit(request.getPeriodLimit());
            department.setAlertThreshold(request.getAlertThreshold());
            department.setOverLimitAction(
                StringUtils.hasText(request.getOverLimitAction()) ? request.getOverLimitAction() : "alert"
            );
        }

        return getDepartmentOverview(department.getId());
    }

    /**
     * 更新部门
     */
    @Transactional(rollbackFor = Exception.class)
    public boolean updateDepartment(Long id, DepartmentUpdateRequest request) {
        Department existDept = getDepartmentById(id);
        if (existDept == null) {
            throw new BusinessException("部门不存在");
        }

        if (StringUtils.hasText(request.getDeptName())) {
            existDept.setDeptName(request.getDeptName());
        }
        if (StringUtils.hasText(request.getDeptCode())) {
            existDept.setDeptCode(request.getDeptCode());
        }
        if (StringUtils.hasText(request.getDeptType())) {
            validateDeptType(request.getDeptType());
            existDept.setDeptType(request.getDeptType());
        }
        // 处理parentId：允许设置为0来清除（设置为null）
        if (request.getParentId() != null) {
            Long parentId = request.getParentId();
            existDept.setParentId(parentId == 0 ? null : parentId);
        }
        // 处理leaderId：前端总是发送leaderId字段
        // null表示清除负责人，非null数字表示设置负责人
        // 由于无法区分字段不存在和字段为null，前端必须总是发送此字段
        // 如果前端不发送字段，这里getLeaderId()也会返回null，但不会更新（保持原值）
        // 为了支持清除，我们检查：如果leaderId字段在请求中存在（通过检查其他必填字段），则处理
        // 简化方案：总是检查leaderId，如果为null且当前有值，则清除；如果为数字，则设置
        // 但由于无法判断字段是否存在，我们采用：如果leaderId不为null，则更新
        if (request.getLeaderId() != null) {
            Long leaderId = request.getLeaderId();
            // 验证负责人ID是否有效（0表示清除，大于0需要验证）
            if (leaderId > 0) {
                User leader = userMapper.selectById(leaderId);
                if (leader == null) {
                    throw new BusinessException("指定的负责人不存在");
                }
            }
            existDept.setLeaderId(leaderId == 0 ? null : leaderId);
        } else if (request.getDeptName() != null) {
            // 如果其他字段被更新（说明这是完整的更新请求），且leaderId为null，则清除负责人
            // 这是一个启发式判断：如果请求包含deptName（通常是必填字段），则认为leaderId=null是明确的清除操作
            existDept.setLeaderId(null);
        }
        // 否则（leaderId为null且没有其他字段更新），不处理leaderId，保持原值
        if (request.getSortOrder() != null) {
            existDept.setSortOrder(request.getSortOrder());
        }
        if (request.getStatus() != null) {
            existDept.setStatus(request.getStatus());
        }
        if (request.getAllowedDemandTypes() != null) {
            existDept.setAllowedDemandTypes(joinAllowedTypes(request.getAllowedDemandTypes()));
        }
        if (request.getLimitEnabled() != null) {
            existDept.setLimitEnabled(request.getLimitEnabled());
        }
        if (request.getLimitPeriod() != null) {
            existDept.setLimitPeriod(request.getLimitPeriod());
        }
        if (request.getPeriodLimit() != null) {
            existDept.setPeriodLimit(request.getPeriodLimit());
        }
        if (request.getAlertThreshold() != null) {
            existDept.setAlertThreshold(request.getAlertThreshold());
        }
        if (request.getOverLimitAction() != null) {
            existDept.setOverLimitAction(request.getOverLimitAction());
        }

        departmentMapper.updateById(existDept);

        // 同步积分池（需求部门和一级需求部门都需要积分池）
        teamScorePoolService.upsertPool(existDept.getId(), existDept.getDeptName());
        if (("demand".equals(existDept.getDeptType()) || "primary_demand".equals(existDept.getDeptType())) &&
            (request.getLimitEnabled() != null || request.getLimitPeriod() != null ||
             request.getPeriodLimit() != null || request.getAlertThreshold() != null)) {
            teamScorePoolService.updateLimitConfig(
                existDept.getId(),
                request.getLimitEnabled(),
                request.getLimitPeriod(),
                request.getPeriodLimit(),
                request.getAlertThreshold()
            );
        }

        return true;
    }

    /**
     * 更新部门限制配置
     */
    @Transactional(rollbackFor = Exception.class)
    public boolean updateLimitSettings(Long deptId, DepartmentLimitSettingsRequest request) {
        Department department = getDepartmentById(deptId);
        if (department == null) {
            throw new BusinessException("部门不存在");
        }
        if (!"demand".equals(department.getDeptType()) && !"primary_demand".equals(department.getDeptType())) {
            throw new BusinessException("只有需求部门或一级需求部门需要配置积分限制");
        }

        department.setLimitEnabled(request.getLimitEnabled());
        department.setLimitPeriod(request.getLimitPeriod());
        department.setPeriodLimit(request.getPeriodLimit());
        department.setAlertThreshold(request.getAlertThreshold());
        department.setOverLimitAction(request.getOverLimitAction());
        departmentMapper.updateById(department);

        teamScorePoolService.updateLimitConfig(
            deptId,
            request.getLimitEnabled(),
            request.getLimitPeriod(),
            request.getPeriodLimit(),
            request.getAlertThreshold()
        );
        return true;
    }

    /**
     * 删除部门（逻辑删除）
     */
    @Transactional(rollbackFor = Exception.class)
    public boolean deleteDepartment(Long id) {
        long childCount = departmentMapper.selectCount(
            new LambdaQueryWrapper<Department>()
                .eq(Department::getParentId, id)
        );
        if (childCount > 0) {
            throw new BusinessException("该部门下还有子部门，无法删除");
        }

        return departmentMapper.deleteById(id) > 0;
    }

    /**
     * 设置部门负责人/主管
     */
    @Transactional(rollbackFor = Exception.class)
    public boolean setDepartmentHead(Long deptId, Long userId, String type) {
        Department department = getDepartmentById(deptId);
        if (department == null) {
            throw new BusinessException("部门不存在");
        }

        if ("head".equals(type)) {
            if (!"demand".equals(department.getDeptType()) && !"primary_demand".equals(department.getDeptType())) {
                throw new BusinessException("只有需求部门或一级需求部门可以设置负责人");
            }
            department.setLeaderId(userId);
        } else if ("supervisor".equals(type)) {
            if (!"receiving".equals(department.getDeptType())) {
                throw new BusinessException("只有接单部门可以设置主管");
            }
            department.setSupervisorId(userId);
        } else {
            throw new BusinessException("类型参数错误");
        }

        return departmentMapper.updateById(department) > 0;
    }

    /**
     * 调整部门积分
     */
    @Transactional(rollbackFor = Exception.class)
    public void adjustScore(Long deptId, DepartmentScoreAdjustRequest request) {
        Department department = getDepartmentById(deptId);
        if (department == null) {
            throw new BusinessException("部门不存在");
        }
        if (!"demand".equals(department.getDeptType()) && !"primary_demand".equals(department.getDeptType())) {
            throw new BusinessException("只有需求部门或一级需求部门可以调整积分");
        }
        if (request.getAmount() == null || request.getAmount() <= 0) {
            throw new BusinessException("调整积分必须大于0");
        }

        String action = request.getAction().toLowerCase();
        switch (action) {
            case "recharge" -> teamScorePoolService.rechargeScore(deptId, request.getAmount());
            case "deduct" -> teamScorePoolService.deductScore(deptId, request.getAmount());
            default -> throw new BusinessException("不支持的积分操作类型");
        }
    }

    private void validateDeptType(String deptType) {
        if (!"demand".equals(deptType) && !"receiving".equals(deptType) && !"primary_demand".equals(deptType)) {
            throw new BusinessException("部门类型必须是 demand、receiving 或 primary_demand");
        }
    }
    
    // ==================== 品牌关联管理 ====================
    
    /**
     * 根据品牌ID获取负责的需求部门
     */
    public Department getDemandDeptByBrandId(Long brandId) {
        if (brandId == null) {
            return null;
        }
        Long deptId = deptBrandRelationMapper.getDeptIdByBrandId(brandId);
        if (deptId == null) {
            return null;
        }
        return departmentMapper.selectById(deptId);
    }
    
    /**
     * 设置部门负责的品牌
     */
    @Transactional(rollbackFor = Exception.class)
    public void setDeptResponsibleBrands(Long deptId, List<Long> brandIds) {
        Department department = getDepartmentById(deptId);
        if (department == null) {
            throw new BusinessException("部门不存在");
        }
        if (!"demand".equals(department.getDeptType())) {
            throw new BusinessException("只有需求部门可以设置负责品牌");
        }
        
        // 检查品牌是否已被其他部门负责
        if (!CollectionUtils.isEmpty(brandIds)) {
            for (Long brandId : brandIds) {
                Long existingDeptId = deptBrandRelationMapper.getDeptIdByBrandId(brandId);
                if (existingDeptId != null && !existingDeptId.equals(deptId)) {
                    Brand brand = brandMapper.selectById(brandId);
                    Department existingDept = departmentMapper.selectById(existingDeptId);
                    throw new BusinessException("品牌 [" + (brand != null ? brand.getName() : brandId) + 
                            "] 已被部门 [" + (existingDept != null ? existingDept.getDeptName() : existingDeptId) + "] 负责");
                }
            }
        }
        
        // 删除原有关联
        deptBrandRelationMapper.deleteByDeptId(deptId);
        
        // 批量插入新关联
        if (!CollectionUtils.isEmpty(brandIds)) {
            deptBrandRelationMapper.batchInsert(deptId, brandIds);
        }
        
        log.info("设置部门 {} 负责品牌: {}", deptId, brandIds);
    }
    
    /**
     * 获取部门负责的品牌列表
     */
    public List<Brand> getDeptResponsibleBrands(Long deptId) {
        List<Long> brandIds = deptBrandRelationMapper.getBrandIdsByDeptId(deptId);
        if (CollectionUtils.isEmpty(brandIds)) {
            return Collections.emptyList();
        }
        return brandMapper.selectBatchIds(brandIds);
    }
    
    /**
     * 获取部门负责的品牌ID列表
     */
    public List<Long> getDeptResponsibleBrandIds(Long deptId) {
        return deptBrandRelationMapper.getBrandIdsByDeptId(deptId);
    }
    
    /**
     * 获取所有品牌-部门关联关系
     */
    public List<DeptBrandRelation> getAllBrandDeptRelations() {
        return deptBrandRelationMapper.getAllRelationsWithNames();
    }
    
    /**
     * 检查部门是否为一级需求部门
     */
    public boolean isPrimaryDemandDept(Long deptId) {
        if (deptId == null) {
            return false;
        }
        Department dept = getDepartmentById(deptId);
        return dept != null && "primary_demand".equals(dept.getDeptType());
    }
    
    /**
     * 检查部门是否可以发起任务（需求部门或一级需求部门）
     */
    public boolean canPublishTask(Long deptId) {
        if (deptId == null) {
            return false;
        }
        Department dept = getDepartmentById(deptId);
        if (dept == null) {
            return false;
        }
        String deptType = dept.getDeptType();
        return "demand".equals(deptType) || "primary_demand".equals(deptType);
    }
    
    /**
     * 获取所有一级需求部门
     */
    public List<Department> getPrimaryDemandDepartments() {
        return departmentMapper.selectList(
            new LambdaQueryWrapper<Department>()
                .eq(Department::getDeptType, "primary_demand")
                .eq(Department::getStatus, 1)
                .orderByAsc(Department::getSortOrder)
        );
    }

    /**
     * 获取所有需求部门的ID列表（只包括 demand 类型，不包括 primary_demand）
     * 用于跨部门成员分配功能
     * 注意：一级需求部门(primary_demand)的成员不应该出现在下拉列表中
     */
    public List<Long> getAllDemandDeptIds() {
        List<Department> demandDepts = departmentMapper.selectList(
            new LambdaQueryWrapper<Department>()
                .eq(Department::getDeptType, "demand")  // 只查询 demand 类型，不包括 primary_demand
                .eq(Department::getStatus, 1)
                .eq(Department::getDeleted, 0)
        );
        
        List<Long> allDeptIds = new java.util.ArrayList<>();
        for (Department dept : demandDepts) {
            allDeptIds.add(dept.getId());
            // 递归获取所有子部门ID
            allDeptIds.addAll(getAllChildDeptIds(dept.getId()));
        }
        
        return allDeptIds;
    }

    private Integer defaultLimitEnabled(Integer limitEnabled) {
        return limitEnabled != null ? limitEnabled : 0;
    }

    private String defaultLimitPeriod(String limitPeriod) {
        return StringUtils.hasText(limitPeriod) ? limitPeriod : "MONTHLY";
    }

    private String joinAllowedTypes(List<String> allowedTypes) {
        if (CollectionUtils.isEmpty(allowedTypes)) {
            return null;
        }
        return allowedTypes.stream()
            .filter(StringUtils::hasText)
            .collect(Collectors.joining(","));
    }

    private List<String> splitAllowedTypes(String allowedTypes) {
        if (allowedTypes == null || allowedTypes.trim().isEmpty()) {
            return Collections.emptyList();
        }
        return Arrays.stream(allowedTypes.split(","))
            .map(String::trim)
            .filter(StringUtils::hasText)
            .collect(Collectors.toList());
    }

    private Map<Long, Long> loadMemberCountMap() {
        // 只统计启用且未删除的用户
        return userMapper.selectList(
            new LambdaQueryWrapper<User>()
                .eq(User::getStatus, 1)
                .eq(User::getDeleted, 0)
        ).stream()
            .filter(user -> user.getDeptId() != null)
            .collect(Collectors.groupingBy(
                User::getDeptId,
                Collectors.counting()
            ));
    }

    private Map<Long, String> loadLeaderNames(List<Department> departments) {
        List<Long> leaderIds = departments.stream()
            .map(Department::getLeaderId)
            .filter(Objects::nonNull)
            .distinct()
            .collect(Collectors.toList());
        if (leaderIds.isEmpty()) {
            return Collections.emptyMap();
        }
        return userMapper.selectBatchIds(leaderIds).stream()
            .collect(Collectors.toMap(
                User::getId,
                user -> StringUtils.hasText(user.getRealName()) ? user.getRealName() : user.getUsername()
            ));
    }

    private DepartmentOverviewVO buildOverviewVO(Department department,
                                                 Map<Long, Long> memberCountMap,
                                                 Map<Long, String> leaderNameMap) {
        DepartmentOverviewVO vo = new DepartmentOverviewVO();
        vo.setId(department.getId());
        vo.setDeptName(department.getDeptName());
        vo.setDeptCode(department.getDeptCode());
        vo.setDeptType(department.getDeptType());
        vo.setParentId(department.getParentId());
        vo.setLeaderId(department.getLeaderId());
        if (department.getLeaderId() != null && leaderNameMap != null) {
            vo.setLeaderName(leaderNameMap.get(department.getLeaderId()));
        }
        vo.setDescription(department.getDescription());
        vo.setSortOrder(department.getSortOrder());
        vo.setStatus(department.getStatus());
        vo.setAllowedDemandTypes(splitAllowedTypes(department.getAllowedDemandTypes()));

        var pool = teamScorePoolService.getByDeptId(department.getId());
        if (pool != null) {
            vo.setScoreBalance(pool.getBalance());
            vo.setTotalRecharge(pool.getTotalRecharge());
            vo.setTotalConsume(pool.getTotalConsume());
            vo.setTotalEarn(pool.getTotalEarn());
            vo.setLimitEnabled(pool.getLimitEnabled());
            vo.setLimitPeriod(pool.getLimitPeriod());
            vo.setPeriodLimit(pool.getPeriodLimit());
            vo.setPeriodUsed(pool.getPeriodUsed());
            vo.setAlertThreshold(pool.getAlertThreshold());
            vo.setLimitAlert(teamScorePoolService.isAlert(department.getId()));
        } else {
            vo.setScoreBalance(department.getScoreBalance());
            vo.setLimitEnabled(department.getLimitEnabled());
            vo.setLimitPeriod(department.getLimitPeriod());
            vo.setPeriodLimit(department.getPeriodLimit());
            vo.setAlertThreshold(department.getAlertThreshold());
            vo.setLimitAlert(false);
        }
        vo.setOverLimitAction(department.getOverLimitAction());

        if (memberCountMap != null && memberCountMap.containsKey(department.getId())) {
            vo.setMemberCount(memberCountMap.get(department.getId()).intValue());
        } else {
            vo.setMemberCount(0);
        }
        return vo;
    }

    /**
     * 构建树形结构
     */
    private List<Department> buildTree(List<Department> allDepts, Long parentId) {
        List<Department> children = allDepts.stream()
            .filter(dept -> {
                Long deptParentId = dept.getParentId();
                if (deptParentId == null) {
                    return parentId == null || parentId == 0L;
                }
                return deptParentId.equals(parentId);
            })
            .collect(Collectors.toList());

        for (Department child : children) {
            buildTree(allDepts, child.getId());
        }

        return children;
    }
    
    /**
     * 获取部门的所有子部门ID（递归）
     */
    public List<Long> getAllChildDeptIds(Long deptId) {
        List<Long> result = new ArrayList<>();
        if (deptId == null) {
            return result;
        }
        
        // 查找直接子部门（只查询未删除且启用的部门）
        List<Department> children = departmentMapper.selectList(
            new LambdaQueryWrapper<Department>()
                .eq(Department::getParentId, deptId)
                .eq(Department::getDeleted, 0)
                .eq(Department::getStatus, 1)
        );
        
        // 递归获取所有子部门
        for (Department child : children) {
            result.add(child.getId());
            result.addAll(getAllChildDeptIds(child.getId()));
        }
        
        log.info("获取部门{}的所有子部门ID: {}", deptId, result);
        return result;
    }
    
    /**
     * 检查用户是否为任何部门的负责人
     */
    public boolean isUserDepartmentLeader(Long userId) {
        if (userId == null) {
            return false;
        }
        
        // 查询是否有部门的 leader_id 等于该用户ID
        Long count = departmentMapper.selectCount(
                new LambdaQueryWrapper<Department>()
                        .eq(Department::getLeaderId, userId)
                        .eq(Department::getStatus, 1)
        );
        
        return count != null && count > 0;
    }
}