package com.webmanage.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.webmanage.common.BusinessException;
import com.webmanage.dto.PointsRuleDTO;

import com.webmanage.emun.RuleTypeEnum;
import com.webmanage.entity.Points;
import com.webmanage.entity.PointsRule;
import com.webmanage.mapper.PointsRuleMapper;
import com.webmanage.service.PointsRuleService;
import com.webmanage.service.PointsService;

import com.webmanage.vo.PointsRuleResultVO;
import com.webmanage.vo.PointsRuleVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.beans.Transient;
import java.text.DateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 积分规则Service实现类
 */
@Slf4j
@Service
public class PointsRuleServiceImpl extends ServiceImpl<PointsRuleMapper, PointsRule> implements PointsRuleService {
    
    @Autowired
    private PointsService pointsService;


    @Override
    public PointsRuleResultVO getPointsRuleList(Long ruleId) {

        QueryWrapper<PointsRule> wrapper = new QueryWrapper<>();

        wrapper.eq("deleted", 0).eq("is_enabled",0);

        if(ruleId != null){
        wrapper.eq("points_id", ruleId);
        }

        List<PointsRule> list = list(wrapper);
        PointsRuleResultVO pointsRuleResultVO = new PointsRuleResultVO();
        if (!CollectionUtil.isEmpty(list)) {
            Map<Integer, List<PointsRule>> collect = list.stream().collect(Collectors.groupingBy(PointsRule::getRuleType));

            Map<String, List<PointsRule>> getRules = collect.get(RuleTypeEnum.GET.getCode()).stream().collect(Collectors.groupingBy(PointsRule::getCategory));
            Map<String, List<PointsRule>> consumeRules = collect.get(RuleTypeEnum.CONSUME.getCode()).stream().collect(Collectors.groupingBy(PointsRule::getCategory));
            List<PointsRuleVO> getPointsRuleVOList = new ArrayList<>();
            List<PointsRuleVO> consumePointsRuleVOList = new ArrayList<>();
            getRules.forEach((k,v)->{
                PointsRuleVO pointsRuleVO = new PointsRuleVO();
                pointsRuleVO.setRlueSort(v.get(0).getRuleOrder());
                pointsRuleVO.setCategory(k);
                pointsRuleVO.setPointsRules(v);
                getPointsRuleVOList.add(pointsRuleVO);

            });
            consumeRules.forEach((k,v)->{
                PointsRuleVO pointsRuleVO = new PointsRuleVO();
                pointsRuleVO.setRlueSort(v.get(0).getRuleOrder());
                pointsRuleVO.setCategory(k);
                pointsRuleVO.setPointsRules(v);
                consumePointsRuleVOList.add(pointsRuleVO);

            });
            getPointsRuleVOList.sort(Comparator.comparing(PointsRuleVO::getRlueSort));
            consumePointsRuleVOList.sort(Comparator.comparing(PointsRuleVO::getRlueSort));
            pointsRuleResultVO.setGetPointsRuleList(getPointsRuleVOList);
            pointsRuleResultVO.setConsumePointsRuleList(consumePointsRuleVOList);
        }

        return pointsRuleResultVO;
    }

    @Override
    public boolean addPointsRule(PointsRuleDTO pointsRuleDTO) {
        // 验证规则名称是否重复
        QueryWrapper<PointsRule> wrapper = new QueryWrapper<>();
        wrapper.eq("rule_name", pointsRuleDTO.getRuleName())
               .eq("deleted", 0);
        
        if (count(wrapper) > 0) {
            throw new BusinessException("规则名称已存在");
        }
        
        PointsRule pointsRule = new PointsRule();
        BeanUtils.copyProperties(pointsRuleDTO, pointsRule);
        
        return save(pointsRule);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updatePointsRule(List<PointsRuleDTO> pointsRuleDTO) {
        if (CollectionUtils.isEmpty(pointsRuleDTO)){
            return false;
        }

        // 查询规则名称
         Points pointsOld = pointsService.query().eq("id", pointsRuleDTO.get(0).getPointsId())
                 .eq("deleted", 0).one();
        // 查询当天是否有版本更新记录
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("YYYY-MM-DD HH:mm:ss");
        LocalDateTime nowDatetime = LocalDateTime.now();
        LocalDateTime localDateTimeStart = nowDatetime.toLocalDate().atStartOfDay();
        LocalDateTime localDateTimeEnd = nowDatetime.toLocalDate().atStartOfDay();
        // dateTimeFormatter.format(localDateTimeStart), dateTimeFormatter.format(localDateTimeEnd)
        Long counts = pointsService.query().between("created_at", localDateTimeStart, localDateTimeEnd).count();
        // 创建新的积分主表记录
        Points points = new Points();
        points.setPointsName(pointsOld.getPointsName());
        points.setEffectiveStart(LocalDateTime.now());
        points.setModifierId(pointsOld.getModifierId()); // 这里应该从上下文中获取当前用户ID
        points.setModifierName("admin"); // 这里应该从上下文中获取当前用户名
        points.setVersion(counts>0 ? pointsOld.getVersion() + 0.1f: 1.0f);
        points.setStatus(0);
        pointsService.save(points);
        
        // 创建积分规则记录
        for (PointsRuleDTO ruleDTO : pointsRuleDTO) {
            PointsRule pointsRule = new PointsRule();
            BeanUtils.copyProperties(ruleDTO,pointsRule);
            pointsRule.setPointsId(points.getId());
            pointsRule.setUpdatedAt(LocalDateTime.now());
            save(pointsRule);
        }

        return true;
    }

    @Override
    public boolean deletePointsRule(Long id) {
        if (id == null) {
            throw new BusinessException("规则ID不能为空");
        }
        
        PointsRule pointsRule = getById(id);
        if (pointsRule == null) {
            throw new BusinessException("积分规则不存在");
        }
        
        return removeById(id);
    }

    @Override
    public boolean togglePointsRuleStatus(Long id, Boolean isEnabled) {
        if (id == null) {
            throw new BusinessException("规则ID不能为空");
        }
        
        PointsRule pointsRule = getById(id);
        if (pointsRule == null) {
            throw new BusinessException("积分规则不存在");
        }
        
        pointsRule.setIsEnabled(isEnabled ? 0: 1);
        pointsRule.setUpdatedAt(LocalDateTime.now());
        
        return updateById(pointsRule);
    }

    @Override
    public List<PointsRule> getEnabledRulesByType(String ruleType) {
        QueryWrapper<PointsRule> wrapper = new QueryWrapper<>();
        wrapper.eq("deleted", 0)
               .eq("is_enabled", true)
               .eq("rule_type", ruleType)
               .orderByAsc("priority", "created_at");
        
        return list(wrapper);
    }

    @Override
    public PointsRule getRuleByTriggerCondition(String triggerCondition) {
        if (!StringUtils.hasText(triggerCondition)) {
            return null;
        }
        
        QueryWrapper<PointsRule> wrapper = new QueryWrapper<>();
        wrapper.eq("deleted", 0)
               .eq("is_enabled", true)
               .eq("trigger_condition", triggerCondition)
               .orderByAsc("priority")
               .last("LIMIT 1");
        
        return getOne(wrapper);
    }
}