package shop.alien.store.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import shop.alien.entity.store.BarPerformance;
import shop.alien.entity.store.StoreStaffConfig;
import shop.alien.entity.store.vo.BarPerformanceDetailVo;
import shop.alien.entity.store.vo.PerformerVo;
import shop.alien.mapper.BarPerformanceMapper;
import shop.alien.mapper.StoreStaffConfigMapper;
import shop.alien.store.service.BarPerformanceService;
import shop.alien.store.util.ai.AiContentModerationUtil;

import java.time.LocalTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 酒吧演出服务实现类
 * 实现酒吧演出的CRUD、审核、上下线等核心业务功能
 *
 * @author assistant
 * @since 2025-12-17
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class BarPerformanceServiceImpl implements BarPerformanceService {

    private final BarPerformanceMapper barPerformanceMapper;
    private final StoreStaffConfigMapper storeStaffConfigMapper;
    private final AiContentModerationUtil aiContentModerationUtil;

    @Override
    public IPage<BarPerformance> getBarPerformanceList(int page, int size, String status) {
        IPage<BarPerformance> performancePage = new Page<>(page, size);
        QueryWrapper<BarPerformance> queryWrapper = new QueryWrapper<>();
        // 根据状态查询演出
        queryWrapper.like(StringUtils.isNotEmpty(status), "status", status);
        // 只查询未删除的记录
        queryWrapper.eq("delete_flag", 0);
        // 按创建时间降序排序
        queryWrapper.orderByDesc("created_time");
        return barPerformanceMapper.selectPage(performancePage, queryWrapper);
    }

    @Override
    public BarPerformance addOrUpdateBarPerformance(BarPerformance barPerformance) {
        // 1. 演出名称验证：必填且限20字
        if (StringUtils.isEmpty(barPerformance.getPerformanceName())) {
            throw new IllegalArgumentException("演出名称不能为空");
        }
        if (barPerformance.getPerformanceName().length() > 20) {
            throw new IllegalArgumentException("演出名称长度不能超过20个字符");
        }

        // 2. 演出海报验证：必填且限1张
        if (StringUtils.isEmpty(barPerformance.getPerformancePoster())) {
            throw new IllegalArgumentException("演出海报不能为空");
        }

        // 3. 演出类型和频次的关联验证：特邀演出（0）只能选单次（0）
        if (barPerformance.getPerformanceType() != null && barPerformance.getPerformanceType() == 0) {
            // 特邀演出
            if (StringUtils.isEmpty(barPerformance.getPerformanceFrequency()) || !"0".equals(barPerformance.getPerformanceFrequency())) {
                throw new IllegalArgumentException("特邀演出只能选择单次演出");
            }
        }

        // 4. 演出频次相关验证
        String performanceFrequency = barPerformance.getPerformanceFrequency();
        if (StringUtils.isEmpty(performanceFrequency)) {
            throw new IllegalArgumentException("演出频次不能为空");
        }

        // 获取今天的开始时间（用于时间验证）
        java.util.Calendar cal = java.util.Calendar.getInstance();
        cal.set(java.util.Calendar.HOUR_OF_DAY, 0);
        cal.set(java.util.Calendar.MINUTE, 0);
        cal.set(java.util.Calendar.SECOND, 0);
        cal.set(java.util.Calendar.MILLISECOND, 0);
        Date todayStart = cal.getTime();

        switch (performanceFrequency) {
            case "0": // 单次演出
                if (barPerformance.getSingleStartDatetime() == null) {
                    throw new IllegalArgumentException("单次演出必须填写开始时间");
                }
                if (barPerformance.getSingleEndDatetime() == null) {
                    throw new IllegalArgumentException("单次演出必须填写结束时间");
                }
                // 单次演出不需要周天数据，清除周天字段（设置为空字符串，确保数据库插入时包含该字段）
                barPerformance.setPerformanceWeek("");
                break;
            case "1": // 每天定时
                if (barPerformance.getDailyStartDate() == null) {
                    throw new IllegalArgumentException("每天定时演出必须填写开始日期");
                }
                if (barPerformance.getDailyEndDate() == null) {
                    throw new IllegalArgumentException("每天定时演出必须填写结束日期");
                }
                // 验证开始日期必须是今天或以后
                if (barPerformance.getDailyStartDate().before(todayStart)) {
                    throw new IllegalArgumentException("开始日期必须是今天或以后");
                }
                // 确保开始日期早于或等于结束日期
                if (barPerformance.getDailyStartDate().after(barPerformance.getDailyEndDate())) {
                    throw new IllegalArgumentException("开始日期不能晚于结束日期");
                }
                // 验证时间字段（使用single_start_datetime和single_end_datetime，提取时间部分）
                if (barPerformance.getSingleStartDatetime() == null) {
                    throw new IllegalArgumentException("每天定时演出必须填写开始时间");
                }
                if (barPerformance.getSingleEndDatetime() == null) {
                    throw new IllegalArgumentException("每天定时演出必须填写结束时间");
                }
                // 从single_start_datetime和single_end_datetime中提取时间部分，存到daily_start_time和daily_end_time
                LocalTime startTime = barPerformance.getSingleStartDatetime().toInstant()
                        .atZone(ZoneId.systemDefault())
                        .toLocalTime();
                LocalTime endTime = barPerformance.getSingleEndDatetime().toInstant()
                        .atZone(ZoneId.systemDefault())
                        .toLocalTime();
                barPerformance.setDailyStartTime(startTime);
                barPerformance.setDailyEndTime(endTime);
                // 每天定时不需要周天数据，清除周天字段（设置为空字符串，确保数据库插入时包含该字段）
                barPerformance.setPerformanceWeek("");
                break;
            case "2": // 每周定时
                // 验证开始日期必须是今天或以后
                if (barPerformance.getDailyStartDate() != null && barPerformance.getDailyStartDate().before(todayStart)) {
                    throw new IllegalArgumentException("开始日期必须是今天或以后");
                }
                // 确保开始日期早于或等于结束日期
                if (barPerformance.getDailyEndDate() != null && barPerformance.getDailyStartDate() != null && barPerformance.getDailyStartDate().after(barPerformance.getDailyEndDate())) {
                    throw new IllegalArgumentException("开始日期不能晚于结束日期");
                }
                // 每周定时演出需要验证演出日期（周几）
                if (StringUtils.isEmpty(barPerformance.getPerformanceWeek())) {
                    throw new IllegalArgumentException("每周定时演出必须选择演出日期");
                }
                // 验证时间字段（使用single_start_datetime和single_end_datetime，提取时间部分）
                if (barPerformance.getSingleStartDatetime() == null) {
                    throw new IllegalArgumentException("每周定时演出必须填写开始时间");
                }
                if (barPerformance.getSingleEndDatetime() == null) {
                    throw new IllegalArgumentException("每周定时演出必须填写结束时间");
                }
                // 校验：选择的日期（singleStartDatetime 的星期几）必须是 performanceWeek 中的某一天
//                int startDayOfWeek = getDayOfWeekAsPerformanceWeek(barPerformance.getSingleStartDatetime());
//                Set<Integer> allowedWeekDays = parsePerformanceWeekToSet(barPerformance.getPerformanceWeek());
//                if (!allowedWeekDays.contains(startDayOfWeek)) {
//                    throw new IllegalArgumentException("选择的开始日期对应的星期几必须在演出日期（周几）范围内");
//                }
                // 从single_start_datetime和single_end_datetime中提取时间部分，存到daily_start_time和daily_end_time
                LocalTime weeklyStartTime = barPerformance.getSingleStartDatetime().toInstant()
                        .atZone(ZoneId.systemDefault())
                        .toLocalTime();
                LocalTime weeklyEndTime = barPerformance.getSingleEndDatetime().toInstant()
                        .atZone(ZoneId.systemDefault())
                        .toLocalTime();
                barPerformance.setDailyStartTime(weeklyStartTime);
                barPerformance.setDailyEndTime(weeklyEndTime);
                break;
            default:
                throw new IllegalArgumentException("演出频次类型无效");
        }

        // 5. 图文详情图片验证：最多9张
        if (StringUtils.isNotEmpty(barPerformance.getPerformanceDetail())) {
            String[] detailImages = barPerformance.getPerformanceDetail().split(",");
            if (detailImages.length > 9) {
                throw new IllegalArgumentException("图文详情图片最多只能上传9张");
            }
            // 检查每张图片URL格式是否有效
            for (String imageUrl : detailImages) {
                if (StringUtils.isEmpty(imageUrl.trim())) {
                    throw new IllegalArgumentException("图文详情图片URL不能为空");
                }
            }
        }

        // 6. 演出须知字数验证：限300字
        if (StringUtils.isNotEmpty(barPerformance.getPerformanceNotice()) && barPerformance.getPerformanceNotice().length() > 300) {
            throw new IllegalArgumentException("演出须知不能超过300个字符");
        }

        // 7. 图文详情文字验证：限300字（如果有performanceContent字段）
        if (StringUtils.isNotEmpty(barPerformance.getPerformanceContent()) && barPerformance.getPerformanceContent().length() > 300) {
            throw new IllegalArgumentException("图文详情文字不能超过300个字符");
        }

        // 8. AI：海报/详情图前端审；auditContent 仅传文案，第二参固定 null
        String moderationText = buildModerationText(barPerformance);
        AiContentModerationUtil.AuditResult auditResult = aiContentModerationUtil.auditContent(moderationText, null);
        if (auditResult == null || !auditResult.isPassed()) {
            // AI审核失败，设置审核状态为2（审核拒绝）并记录拒绝原因，但仍然保存数据
            String failureReason = (auditResult != null && StringUtils.isNotEmpty(auditResult.getFailureReason()))
                    ? auditResult.getFailureReason()
                    : "内容包含违规信息";
            barPerformance.setReviewStatus(2); // 审核拒绝
            barPerformance.setRejectReason(failureReason);
            log.warn("酒吧演出内容审核失败：{}，将保存数据并标记为审核拒绝状态", failureReason);
            // 不抛出异常，继续保存数据，但reviewStatus已设置为2（审核拒绝）
        } else {
            // AI审核通过，设置审核状态为1（审核通过），清除拒绝原因
            barPerformance.setReviewStatus(1); // 审核通过
            barPerformance.setRejectReason(null); // 清除拒绝原因
            // AI审核通过后，如果上线状态未设置，则设置为上线（1）
            if (barPerformance.getOnlineStatus() == null) {
                barPerformance.setOnlineStatus(1); // 上线
            }
            log.info("酒吧演出内容审核通过");
        }

        Integer id = barPerformance.getId();

        if (id == null || id == 0) {
            // 新增操作
            Date nowDate = new Date(System.currentTimeMillis());
            barPerformance.setCreatedTime(nowDate);
            // 设置删除标记为0（未删除）
            if (barPerformance.getDeleteFlag() == null) {
                barPerformance.setDeleteFlag(0);
            }
            // 审核状态已在AI审核结果后设置（1-审核通过 或 2-审核拒绝）
            // 如果AI审核通过，reviewStatus已设置为1，并且onlineStatus已设置为1（上线）
            // 如果AI审核失败，reviewStatus已设置为2，onlineStatus保持为null或0（下线）
            // 如果为null（理论上不应该出现，因为已经执行了AI审核），设置为0（待审核）
            if (barPerformance.getReviewStatus() == null) {
                barPerformance.setReviewStatus(0);
            }
            // 如果上线状态未设置，则根据审核状态设置：
            // - 审核通过（reviewStatus=1）：设置为上线（1）
            // - 其他情况：设置为下线（0）
            if (barPerformance.getOnlineStatus() == null) {
                if (barPerformance.getReviewStatus() != null && barPerformance.getReviewStatus() == 1) {
                    barPerformance.setOnlineStatus(1); // 审核通过，设置为上线
                } else {
                    barPerformance.setOnlineStatus(0); // 审核未通过或其他情况，设置为下线
                }
            }
            // 设置默认隐藏状态为不隐藏（0）
            if (barPerformance.getHidden() == null) {
                barPerformance.setHidden(0);
            }
            // 重置id，让数据库自动生成
            barPerformance.setId(null);
            // 确保 performance_week 不为 null（如果为 null 则设置为空字符串，避免数据库插入错误）
            if (barPerformance.getPerformanceWeek() == null) {
                barPerformance.setPerformanceWeek("");
            }
            int result = barPerformanceMapper.insert(barPerformance);
            if (result > 0) {
                // 返回保存后的对象，包含自动生成的ID和审核状态
                return barPerformance;
            }
            return null;
        } else {
            // 更新操作：先查询记录是否存在
            BarPerformance existing = barPerformanceMapper.selectById(id);
            if (existing == null) {
                // 记录不存在，转为新增操作
                barPerformance.setId(null);
                Date nowDate = new Date(System.currentTimeMillis());
                barPerformance.setCreatedTime(nowDate);
                // 设置默认值
                if (barPerformance.getDeleteFlag() == null) {
                    barPerformance.setDeleteFlag(0);
                }
                if (barPerformance.getStatus() == null) {
                    barPerformance.setStatus(0);
                }
                // 审核状态已在AI审核结果后设置（1-审核通过 或 2-审核拒绝）
                // 如果AI审核通过，reviewStatus已设置为1，并且onlineStatus已设置为1（上线）
                // 如果AI审核失败，reviewStatus已设置为2，onlineStatus保持为null或0（下线）
                // 如果为null（理论上不应该出现，因为已经执行了AI审核），设置为0（待审核）
                if (barPerformance.getReviewStatus() == null) {
                    barPerformance.setReviewStatus(0);
                }
                // 如果上线状态未设置，则根据审核状态设置：
                // - 审核通过（reviewStatus=1）：设置为上线（1）
                // - 其他情况：设置为下线（0）
                if (barPerformance.getOnlineStatus() == null) {
                    if (barPerformance.getReviewStatus() != null && barPerformance.getReviewStatus() == 1) {
                        barPerformance.setOnlineStatus(1); // 审核通过，设置为上线
                    } else {
                        barPerformance.setOnlineStatus(0); // 审核未通过或其他情况，设置为下线
                    }
                }
                if (barPerformance.getHidden() == null) {
                    barPerformance.setHidden(0);
                }
                // 确保 performance_week 不为 null（如果为 null 则设置为空字符串，避免数据库插入错误）
                if (barPerformance.getPerformanceWeek() == null) {
                    barPerformance.setPerformanceWeek("");
                }
                int result = barPerformanceMapper.insert(barPerformance);
                if (result > 0) {
                    // 返回保存后的对象，包含自动生成的ID和审核状态
                    return barPerformance;
                }
                return null;
            } else {
                // 记录存在，执行更新
                int result = barPerformanceMapper.updateById(barPerformance);
                if (result > 0) {
                    // 返回更新后的对象（重新查询以获取完整信息）
                    return barPerformanceMapper.selectById(id);
                }
                return null;
            }
        }
    }

    @Override
    public BarPerformanceDetailVo getBarPerformanceDetail(Integer id) {
        if (id == null || id <= 0) {
            return null;
        }

        // 查询演出基本信息
        QueryWrapper<BarPerformance> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id", id);
        queryWrapper.eq("delete_flag", 0);

        BarPerformance barPerformance = barPerformanceMapper.selectOne(queryWrapper);
        if (barPerformance == null) {
            return null;
        }

        // 检查并更新已删除的员工配置ID
        String originalStaffConfigIds = barPerformance.getStaffConfigIds();
        String updatedStaffConfigIds = checkAndUpdateDeletedStaff(originalStaffConfigIds);
        
        // 如果员工配置ID有变化，更新数据库
        if (updatedStaffConfigIds != null && !updatedStaffConfigIds.equals(originalStaffConfigIds)) {
            try {
                LambdaUpdateWrapper<BarPerformance> updateWrapper = new LambdaUpdateWrapper<>();
                updateWrapper.eq(BarPerformance::getId, id);
                updateWrapper.set(BarPerformance::getStaffConfigIds, updatedStaffConfigIds);
                int updateResult = barPerformanceMapper.update(null, updateWrapper);
                if (updateResult > 0) {
                    // 更新成功，同步更新本地对象
                    barPerformance.setStaffConfigIds(updatedStaffConfigIds);
                    log.info("酒吧演出ID={}的演出嘉宾字段已更新，原值：{}，新值：{}", 
                            id, originalStaffConfigIds, updatedStaffConfigIds);
                }
            } catch (Exception e) {
                log.error("更新酒吧演出ID={}的演出嘉宾字段失败，异常信息：{}", 
                        id, e.getMessage(), e);
            }
        }

        // 转换为VO对象
        BarPerformanceDetailVo detailVo = new BarPerformanceDetailVo();
        BeanUtils.copyProperties(barPerformance, detailVo);

        // 查询并设置表演嘉宾列表（使用更新后的staffConfigIds）
        List<PerformerVo> performers = queryPerformersByStaffConfigIds(barPerformance.getStaffConfigIds());
        detailVo.setPerformers(performers);

        return detailVo;
    }

    /**
     * 检查并更新已删除的员工配置ID
     * 如果发现员工被删除，从staffConfigIds中移除这些已删除的员工ID
     * 
     * @param staffConfigIds 员工配置ID字符串，逗号分隔，如 "41,25"
     * @return 更新后的员工配置ID字符串，如果无变化则返回原值
     */
    private String checkAndUpdateDeletedStaff(String staffConfigIds) {
        if (StringUtils.isEmpty(staffConfigIds)) {
            return staffConfigIds;
        }

        try {
            // 解析员工ID字符串
            String[] idArray = staffConfigIds.split(",");
            List<Integer> originalStaffIdList = new ArrayList<>();
            
            for (String idStr : idArray) {
                if (StringUtils.isNotEmpty(idStr.trim())) {
                    try {
                        Integer staffId = Integer.parseInt(idStr.trim());
                        if (staffId > 0) {
                            originalStaffIdList.add(staffId);
                        }
                    } catch (NumberFormatException e) {
                        log.warn("解析员工配置ID失败，无效的ID：{}", idStr);
                    }
                }
            }

            if (originalStaffIdList.isEmpty()) {
                return staffConfigIds;
            }

            // 批量查询员工配置信息（MyBatis-Plus的selectBatchIds会自动过滤已删除的记录）
            List<StoreStaffConfig> staffList = storeStaffConfigMapper.selectBatchIds(originalStaffIdList);
            
            // 获取实际查询到的员工ID列表（未删除的员工）
            final List<Integer> existingStaffIdList;
            if (staffList != null && !staffList.isEmpty()) {
                existingStaffIdList = staffList.stream()
                        .filter(staff -> staff != null && staff.getDeleteFlag() != null && staff.getDeleteFlag() == 0)
                        .map(StoreStaffConfig::getId)
                        .collect(Collectors.toList());
            } else {
                existingStaffIdList = new ArrayList<>();
            }

            // 比较原始ID列表和查询到的ID列表，找出被删除的员工ID
            List<Integer> deletedStaffIdList = originalStaffIdList.stream()
                    .filter(id -> !existingStaffIdList.contains(id))
                    .collect(Collectors.toList());

            // 如果有员工被删除，更新staffConfigIds字段
            if (!deletedStaffIdList.isEmpty()) {
                log.info("发现酒吧演出关联的员工被删除，员工ID列表：{}", deletedStaffIdList);
                // 构建新的staffConfigIds字符串（只包含未删除的员工ID）
                String updatedStaffConfigIds = existingStaffIdList.stream()
                        .map(String::valueOf)
                        .collect(Collectors.joining(","));
                return updatedStaffConfigIds;
            }
        } catch (Exception e) {
            log.error("检查并更新已删除的员工配置ID异常，staffConfigIds={}，异常信息：{}", 
                    staffConfigIds, e.getMessage(), e);
        }

        return staffConfigIds;
    }

    /**
     * 根据员工配置ID字符串查询表演嘉宾列表
     * 
     * @param staffConfigIds 员工配置ID字符串，逗号分隔，如 "41,25"
     * @return 表演嘉宾列表
     */
    private List<PerformerVo> queryPerformersByStaffConfigIds(String staffConfigIds) {
        List<PerformerVo> performerList = new ArrayList<>();
        
        if (StringUtils.isEmpty(staffConfigIds)) {
            return performerList;
        }

        try {
            // 解析员工ID字符串
            String[] idArray = staffConfigIds.split(",");
            List<Integer> staffIdList = new ArrayList<>();
            
            for (String idStr : idArray) {
                if (StringUtils.isNotEmpty(idStr.trim())) {
                    try {
                        Integer staffId = Integer.parseInt(idStr.trim());
                        if (staffId > 0) {
                            staffIdList.add(staffId);
                        }
                    } catch (NumberFormatException e) {
                        log.warn("解析员工配置ID失败，无效的ID：{}", idStr);
                    }
                }
            }

            if (staffIdList.isEmpty()) {
                return performerList;
            }

            // 批量查询员工配置信息（MyBatis-Plus的selectBatchIds会自动过滤已删除的记录）
            List<StoreStaffConfig> staffList = storeStaffConfigMapper.selectBatchIds(staffIdList);
            
            if (staffList != null && !staffList.isEmpty()) {
                // 过滤已删除的员工，并转换为PerformerVo
                performerList = staffList.stream()
                        .filter(staff -> staff != null && staff.getDeleteFlag() != null && staff.getDeleteFlag() == 0)
                        .map(this::convertToPerformerVo)
                        .collect(Collectors.toList());
            }
        } catch (Exception e) {
            log.error("查询表演嘉宾列表异常，staffConfigIds={}，异常信息：{}", 
                    staffConfigIds, e.getMessage(), e);
        }

        return performerList;
    }

    /**
     * 将StoreStaffConfig转换为PerformerVo
     * 
     * @param staffConfig 员工配置信息
     * @return 表演嘉宾VO
     */
    private PerformerVo convertToPerformerVo(StoreStaffConfig staffConfig) {
        PerformerVo performerVo = new PerformerVo();
        performerVo.setId(staffConfig.getId());
        performerVo.setAvatar(staffConfig.getStaffImage());
        performerVo.setName(staffConfig.getName());
        performerVo.setStyle(staffConfig.getStaffPosition());
        performerVo.setTag(staffConfig.getTag());
        return performerVo;
    }

    @Override
    public Integer deleteBarPerformance(Integer id) {
        if (id == null || id <= 0) {
            return 0;
        }
        // 使用 MyBatis-Plus 的逻辑删除，会自动将 deleteFlag 设置为 1
        return barPerformanceMapper.deleteById(id);
    }

    @Override
    public Integer setOnlineStatus(Integer id, Integer onlineStatus) {
        if (id == null || onlineStatus == null) {
            return 0;
        }

        LambdaUpdateWrapper<BarPerformance> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        lambdaUpdateWrapper.eq(BarPerformance::getId, id);
        lambdaUpdateWrapper.set(BarPerformance::getOnlineStatus, onlineStatus);

        return barPerformanceMapper.update(null, lambdaUpdateWrapper);
    }

    @Override
    public IPage<BarPerformance> queryPerformanceListByStoreId(Integer page, Integer size, Integer storeId, String status) {
        // 使用新的方法，支持按审核状态和分类筛选
        // status参数转换为reviewStatus（对应数据库字段 review_status）
        Integer reviewStatus = null;
        if (StringUtils.isNotEmpty(status)) {
            try {
                reviewStatus = Integer.parseInt(status);
            } catch (NumberFormatException e) {
                // 忽略无效的状态值
            }
        }
        return queryPerformanceListByStoreIdAndCategory(page, size, storeId, reviewStatus, "all", null, null, null, null, null);
    }

    @Override
    public IPage<BarPerformance> queryPerformanceListByStoreIdAndCategory(Integer page, Integer size, Integer storeId, Integer reviewStatus, String category, String performanceName, Integer performanceType, Integer onlineStatus, Date startCreatedTime, Date endCreatedTime) {
        if (page == null || size == null || storeId == null || storeId <= 0) {
            return new Page<>();
        }

        IPage<BarPerformance> performancePage = new Page<>(page, size);
        QueryWrapper<BarPerformance> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("store_id", storeId);

        // 按演出名称搜索（支持模糊搜索）
        if (StringUtils.isNotEmpty(performanceName)) {
            queryWrapper.like("performance_name", performanceName);
        }

        // 按演出类型筛选
        if (performanceType != null) {
            queryWrapper.eq("performance_type", performanceType);
        }

        // 按上线状态筛选
        if (onlineStatus != null) {
            queryWrapper.eq("online_status", onlineStatus);
        }

        // 按审核状态筛选（数据库字段 review_status）
        if (reviewStatus != null) {
            queryWrapper.eq("review_status", reviewStatus);
        } else {
            // 不查询草稿（review_status为null的记录）
            queryWrapper.isNotNull("review_status");
        }

        // 按演出分类筛选
        if (StringUtils.isNotEmpty(category) && !"all".equals(category)) {
            Date now = new Date();
            // 获取今天的开始时间（00:00:00）
            java.util.Calendar cal = java.util.Calendar.getInstance();
            cal.setTime(now);
            cal.set(java.util.Calendar.HOUR_OF_DAY, 0);
            cal.set(java.util.Calendar.MINUTE, 0);
            cal.set(java.util.Calendar.SECOND, 0);
            cal.set(java.util.Calendar.MILLISECOND, 0);
            Date todayStart = cal.getTime();

            switch (category) {
                case "not_started": // 未开始
                    queryWrapper.and(wrapper -> {
                        // 单次演出：开始时间 > 现在
                        wrapper.or(w -> w.eq("performance_frequency", "0")
                                .gt("single_start_datetime", now));
                        // 定时演出：开始日期 > 今天 或 (开始日期 = 今天 但还未到演出时间)
                        wrapper.or(w -> w.in("performance_frequency", "1", "2")
                                .gt("daily_start_date", todayStart));
                    });
                    break;
                case "in_progress": // 进行中
                    queryWrapper.and(wrapper -> {
                        // 单次演出：开始时间 <= 现在 AND 结束时间 >= 现在
                        wrapper.or(w -> w.eq("performance_frequency", "0")
                                .le("single_start_datetime", now)
                                .ge("single_end_datetime", now));
                        // 定时演出：开始日期 <= 今天 AND 结束日期 >= 今天
                        wrapper.or(w -> w.in("performance_frequency", "1", "2")
                                .le("daily_start_date", todayStart)
                                .ge("daily_end_date", todayStart));
                    });
                    break;
                case "ended": // 已结束
                    queryWrapper.and(wrapper -> {
                        // 单次演出：结束时间 < 现在
                        wrapper.or(w -> w.eq("performance_frequency", "0")
                                .lt("single_end_datetime", now));
                        // 定时演出：结束日期 < 今天
                        wrapper.or(w -> w.in("performance_frequency", "1", "2")
                                .lt("daily_end_date", todayStart));
                    });
                    break;
                default:
                    // 其他情况，不添加额外条件
                    break;
            }
        }

        // 按创建时间范围筛选
        if (startCreatedTime != null) {
            queryWrapper.ge("created_time", startCreatedTime);
        }
        if (endCreatedTime != null) {
            queryWrapper.le("created_time", endCreatedTime);
        }

        queryWrapper.eq("delete_flag", 0);
        // 按提交时间（创建时间）倒序排序
        queryWrapper.orderByDesc("created_time");

        return barPerformanceMapper.selectPage(performancePage, queryWrapper);
    }

    /**
     * 将 Date 的星期几转换为 performanceWeek 编码（0=周一，1=周二，…，6=周日）
     * 用于校验选择的日期是否在演出日期（周几）范围内
     *
     * @param date 日期时间
     * @return 0-6，对应周一至周日
     */
    private int getDayOfWeekAsPerformanceWeek(Date date) {
        if (date == null) {
            throw new IllegalArgumentException("日期不能为空");
        }
        java.util.Calendar cal = java.util.Calendar.getInstance();
        cal.setTime(date);
        // Calendar: Sunday=1, Monday=2, ..., Saturday=7
        int calendarDay = cal.get(java.util.Calendar.DAY_OF_WEEK);
        // 转为 performanceWeek 编码：0=周一, 1=周二, ..., 6=周日
        return calendarDay == java.util.Calendar.SUNDAY ? 6 : calendarDay - 2;
    }

    /**
     * 解析 performanceWeek 字符串为允许的星期几集合（0-6）
     * 格式：逗号分隔，如 "0,2,5" 表示周一、周三、周六
     *
     * @param performanceWeek 演出日期字符串
     * @return 允许的星期几集合，空字符串或无效时返回空集合
     */
    private Set<Integer> parsePerformanceWeekToSet(String performanceWeek) {
        if (StringUtils.isEmpty(performanceWeek)) {
            return java.util.Collections.emptySet();
        }
        return Arrays.stream(performanceWeek.split(","))
                .map(String::trim)
                .filter(s -> !s.isEmpty())
                .filter(s -> s.matches("^[0-6]$"))
                .map(Integer::parseInt)
                .collect(Collectors.toSet());
    }

    /**
     * 比较两个时间（只比较时间部分，忽略日期部分）
     * 用于每天定时和每周定时演出的时间验证
     *
     * @param time1 开始时间
     * @param time2 结束时间
     * @return true表示time1早于time2，false表示time1晚于或等于time2
     */
    private boolean isTimeBefore(Date time1, Date time2) {
        if (time1 == null || time2 == null) {
            return false;
        }
        java.util.Calendar cal1 = java.util.Calendar.getInstance();
        cal1.setTime(time1);
        int hour1 = cal1.get(java.util.Calendar.HOUR_OF_DAY);
        int minute1 = cal1.get(java.util.Calendar.MINUTE);
        int second1 = cal1.get(java.util.Calendar.SECOND);

        java.util.Calendar cal2 = java.util.Calendar.getInstance();
        cal2.setTime(time2);
        int hour2 = cal2.get(java.util.Calendar.HOUR_OF_DAY);
        int minute2 = cal2.get(java.util.Calendar.MINUTE);
        int second2 = cal2.get(java.util.Calendar.SECOND);

        // 比较小时
        if (hour1 < hour2) {
            return true;
        } else if (hour1 > hour2) {
            return false;
        }

        // 小时相同，比较分钟
        if (minute1 < minute2) {
            return true;
        } else if (minute1 > minute2) {
            return false;
        }

        // 分钟相同，比较秒
        return second1 < second2;
    }

    /**
     * 构建AI审核文本内容
     * 只包含文本字段，不包含图片URL
     * 
     * @param barPerformance 演出信息
     * @return 审核文本内容
     */
    private String buildModerationText(BarPerformance barPerformance) {
        StringBuilder sb = new StringBuilder();
        if (barPerformance == null) {
            return "";
        }
        // 演出名称（文本）
        if (StringUtils.isNotEmpty(barPerformance.getPerformanceName())) {
            sb.append("演出名称：").append(barPerformance.getPerformanceName()).append("\n");
        }
        // 演出风格（文本）
        if (StringUtils.isNotEmpty(barPerformance.getPerformanceStyle())) {
            sb.append("演出风格：").append(barPerformance.getPerformanceStyle()).append("\n");
        }
        // 演出详情文字（文本，performanceContent字段）
        if (StringUtils.isNotEmpty(barPerformance.getPerformanceContent())) {
            sb.append("演出详情：").append(barPerformance.getPerformanceContent()).append("\n");
        }
        // 演出须知（文本）
        if (StringUtils.isNotEmpty(barPerformance.getPerformanceNotice())) {
            sb.append("演出须知：").append(barPerformance.getPerformanceNotice()).append("\n");
        }
        // 注意：performanceDetail是图片URL列表，不作为文本审核，只作为图片审核
        return sb.toString();
    }
}
