package shop.alien.store.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.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import shop.alien.entity.store.StoreStaffTitle;
import shop.alien.mapper.StoreStaffTitleMapper;
import shop.alien.store.service.StoreStaffTitleService;
import shop.alien.store.util.CommonConstant;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 员工标题服务实现类
 *
 * @author system
 * @since 2025-01-XX
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class StoreStaffTitleServiceImpl extends ServiceImpl<StoreStaffTitleMapper, StoreStaffTitle>
        implements StoreStaffTitleService {

    private final StoreStaffTitleMapper storeStaffTitleMapper;

    /**
     * 分页查询员工标题列表
     *
     * @param page    分页页数，必须大于0
     * @param size    分页条数，必须大于0且不超过100
     * @param storeId 店铺ID，可选
     * @return 员工标题列表分页结果
     */
    @Override
    public IPage<StoreStaffTitle> queryStaffTitleList(Integer page, Integer size, Integer storeId) {
        log.info("查询员工标题列表，参数：page={}, size={}, storeId={}", page, size, storeId);

        // 参数校验
        if (page == null || page < 1) {
            log.warn("查询员工标题列表失败，分页页数无效：page={}", page);
            throw new IllegalArgumentException("分页页数不能为空且必须大于0");
        }
        if (size == null || size < 1) {
            log.warn("查询员工标题列表失败，分页条数无效：size={}", size);
            throw new IllegalArgumentException("分页条数不能为空且必须大于0");
        }
        if (size > CommonConstant.MAX_PAGE_SIZE) {
            log.warn("查询员工标题列表失败，分页条数超过最大值：size={}", size);
            throw new IllegalArgumentException("分页条数不能超过" + CommonConstant.MAX_PAGE_SIZE);
        }

        try {
            // 构建分页对象
            IPage<StoreStaffTitle> staffTitlePage = new Page<>(page, size);

            // 构建查询条件
            LambdaQueryWrapper<StoreStaffTitle> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(StoreStaffTitle::getDeleteFlag, CommonConstant.DELETE_FLAG_UNDELETE);

            // 如果指定了店铺ID，则按店铺ID过滤
            if (storeId != null && storeId > 0) {
                queryWrapper.eq(StoreStaffTitle::getStoreId, storeId);
            }

            // 按创建时间降序排序
            queryWrapper.orderByDesc(StoreStaffTitle::getCreatedTime);

            // 执行查询
            IPage<StoreStaffTitle> result = storeStaffTitleMapper.selectPage(staffTitlePage, queryWrapper);

            log.info("查询员工标题列表成功，共{}条记录，当前页{}条",
                    result.getTotal(), result.getRecords() != null ? result.getRecords().size() : 0);
            return result;
        } catch (Exception e) {
            log.error("查询员工标题列表异常，异常信息：{}", e.getMessage(), e);
            throw new RuntimeException("查询员工标题列表失败：" + e.getMessage(), e);
        }
    }

    /**
     * 新增员工标题
     *
     * @param storeStaffTitle 员工标题信息
     * @return 新增结果，成功返回1，失败返回0
     */
    @Override
    public Integer addStaffTitle(StoreStaffTitle storeStaffTitle) {
        log.info("新增员工标题，参数：{}", storeStaffTitle);

        // 参数校验
        if (storeStaffTitle == null) {
            log.warn("新增员工标题失败，参数为空");
            throw new IllegalArgumentException("员工标题信息不能为空");
        }
        if (StringUtils.isEmpty(storeStaffTitle.getTitleName())) {
            log.warn("新增员工标题失败，标题名称为空");
            throw new IllegalArgumentException("标题名称不能为空");
        }

        // TODO 去重
        List<StoreStaffTitle> titleName = storeStaffTitleMapper.selectList(new QueryWrapper<StoreStaffTitle>().eq("store_id",storeStaffTitle.getStoreId()).eq("title_name", storeStaffTitle.getTitleName()));
        if ( !titleName.isEmpty() ) {
            log.warn("新增员工标题失败，标题名称重复");
            throw new IllegalArgumentException("标题名称不能重复");
        }

        try {
            // 自动计算员工数量
            int staffCount = calculateStaffCount(storeStaffTitle.getStaffIds());
            storeStaffTitle.setStaffCount(staffCount);

            // 设置创建时间
            storeStaffTitle.setCreatedTime(new Date());
            storeStaffTitle.setUpdatedTime(new Date());

            // 执行新增
            int result = storeStaffTitleMapper.insert(storeStaffTitle);

            if (result > 0) {
                log.info("新增员工标题成功，id={}，标题名称={}，员工数量={}",
                        storeStaffTitle.getId(), storeStaffTitle.getTitleName(), staffCount);
            } else {
                log.warn("新增员工标题失败，插入记录数为0");
            }

            return result;
        } catch (Exception e) {
            log.error("新增员工标题异常，异常信息：{}", e.getMessage(), e);
            throw new RuntimeException("新增员工标题失败：" + e.getMessage(), e);
        }
    }

    /**
     * 更新员工标题
     *
     * @param storeStaffTitle 员工标题信息
     * @return 更新结果，成功返回1，失败返回0
     */
    @Override
    public Integer updateStaffTitle(StoreStaffTitle storeStaffTitle) {
        log.info("更新员工标题，参数：{}", storeStaffTitle);

        // 参数校验
        if (storeStaffTitle == null) {
            log.warn("更新员工标题失败，参数为空");
            throw new IllegalArgumentException("员工标题信息不能为空");
        }
        if (storeStaffTitle.getId() == null || storeStaffTitle.getId() <= 0) {
            log.warn("更新员工标题失败，ID无效：id={}", storeStaffTitle.getId());
            throw new IllegalArgumentException("员工标题ID不能为空且必须大于0");
        }
        if (StringUtils.isEmpty(storeStaffTitle.getTitleName())) {
            log.warn("更新员工标题失败，标题名称为空");
            throw new IllegalArgumentException("标题名称不能为空");
        }

        try {
            // 如果更新了员工IDs，重新计算员工数量
            if (StringUtils.isNotEmpty(storeStaffTitle.getStaffIds())) {
                int staffCount = calculateStaffCount(storeStaffTitle.getStaffIds());
                storeStaffTitle.setStaffCount(staffCount);
            }

            // 设置更新时间
            storeStaffTitle.setUpdatedTime(new Date());

            // 执行更新
            int result = storeStaffTitleMapper.updateById(storeStaffTitle);

            if (result > 0) {
                log.info("更新员工标题成功，id={}，标题名称={}",
                        storeStaffTitle.getId(), storeStaffTitle.getTitleName());
            } else {
                log.warn("更新员工标题失败，更新记录数为0，id={}", storeStaffTitle.getId());
            }

            return result;
        } catch (Exception e) {
            log.error("更新员工标题异常，id={}，异常信息：{}", storeStaffTitle.getId(), e.getMessage(), e);
            throw new RuntimeException("更新员工标题失败：" + e.getMessage(), e);
        }
    }

    /**
     * 删除员工标题（逻辑删除）
     *
     * @param id 员工标题ID，必须大于0
     * @return 删除结果，成功返回1，失败返回0
     */
    @Override
    public Integer deleteStaffTitle(Integer id) {
        log.info("删除员工标题，参数：id={}", id);

        // 参数校验
        if (id == null || id <= 0) {
            log.warn("删除员工标题失败，ID无效：id={}", id);
            throw new IllegalArgumentException("员工标题ID不能为空且必须大于0");
        }

        try {
            // 先查询标题信息，检查是否有员工
            StoreStaffTitle title = storeStaffTitleMapper.selectById(id);
            if (title == null) {
                log.warn("删除员工标题失败，标题不存在：id={}", id);
                throw new IllegalArgumentException("员工标题不存在");
            }

            // 校验：如果标题下有员工，不能删除
            if (title.getStaffCount() != null && title.getStaffCount() > 0) {
                log.warn("删除员工标题失败，标题下还有员工，不能删除：id={}，员工数量={}", id, title.getStaffCount());
                throw new IllegalArgumentException("该标题下还有员工，无法删除。请先移除标题下的所有员工后再删除");
            }

            // 双重检查：如果staffIds不为空，也不能删除
            if (StringUtils.isNotEmpty(title.getStaffIds())) {
                // 检查staffIds中是否有有效的员工ID
                List<String> idList = Arrays.stream(title.getStaffIds().split(","))
                        .map(String::trim)
                        .filter(s -> !s.isEmpty())
                        .collect(Collectors.toList());
                if (!idList.isEmpty()) {
                    log.warn("删除员工标题失败，标题下还有员工，不能删除：id={}，员工IDs={}", id, title.getStaffIds());
                    throw new IllegalArgumentException("该标题下还有员工，无法删除。请先移除标题下的所有员工后再删除");
                }
            }

            // 逻辑删除（MyBatis-Plus会自动处理@TableLogic注解）
            int result = storeStaffTitleMapper.deleteById(id);

            if (result > 0) {
                log.info("删除员工标题成功，id={}", id);
            } else {
                log.warn("删除员工标题失败，删除记录数为0，id={}", id);
            }

            return result;
        } catch (IllegalArgumentException e) {
            // 重新抛出IllegalArgumentException，让Controller层处理
            throw e;
        } catch (Exception e) {
            log.error("删除员工标题异常，id={}，异常信息：{}", id, e.getMessage(), e);
            throw new RuntimeException("删除员工标题失败：" + e.getMessage(), e);
        }
    }

    /**
     * 查询员工标题详情
     *
     * @param storeId 门店ID，必须大于0
     * @return 员工标题详情，如果不存在则返回null
     */
    @Override
    public StoreStaffTitle getStaffTitleDetail(Integer storeId) {
        log.info("查询员工标题详情，参数：storeId={}", storeId);

        // 参数校验
        if (storeId == null || storeId <= 0) {
            log.warn("查询员工标题详情失败，门店ID无效：storeId={}", storeId);
            throw new IllegalArgumentException("门店ID不能为空且必须大于0");
        }

        try {
            // 根据门店ID查询标题（一个门店只能有一个标题）
            LambdaQueryWrapper<StoreStaffTitle> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(StoreStaffTitle::getStoreId, storeId)
                    .eq(StoreStaffTitle::getDeleteFlag, CommonConstant.DELETE_FLAG_UNDELETE)
                    .orderByDesc(StoreStaffTitle::getCreatedTime)
                    .last("limit 1");
            
            StoreStaffTitle result = storeStaffTitleMapper.selectOne(queryWrapper);

            if (result == null) {
                log.warn("查询员工标题详情失败，记录不存在：storeId={}", storeId);
            } else {
                log.info("查询员工标题详情成功，storeId={}，id={}，标题名称={}", storeId, result.getId(), result.getTitleName());
            }

            return result;
        } catch (Exception e) {
            log.error("查询员工标题详情异常，storeId={}，异常信息：{}", storeId, e.getMessage(), e);
            throw new RuntimeException("查询员工标题详情失败：" + e.getMessage(), e);
        }
    }

    /**
     * 计算员工数量
     * <p>
     * 根据员工IDs字符串（逗号分隔）计算员工数量
     * </p>
     *
     * @param staffIds 员工IDs字符串（逗号分隔）
     * @return 员工数量
     */
    private int calculateStaffCount(String staffIds) {
        if (StringUtils.isEmpty(staffIds)) {
            return 0;
        }

        try {
            // 按逗号分割，过滤空字符串，计算数量
            List<String> idList = Arrays.stream(staffIds.split(","))
                    .map(String::trim)
                    .filter(s -> !s.isEmpty())
                    .collect(Collectors.toList());

            return idList.size();
        } catch (Exception e) {
            log.error("计算员工数量异常，staffIds={}，异常信息：{}", staffIds, e.getMessage(), e);
            return 0;
        }
    }
}

