package com.ylx.point.service.impl;

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

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ylx.common.core.domain.R;
import com.ylx.common.exception.base.BaseException;
import com.ylx.common.utils.DateUtils;
import com.ylx.point.domain.PointActivityTask;
import com.ylx.point.domain.PointSignReward;
import com.ylx.point.domain.PointSignTask;
import com.ylx.point.domain.dto.*;
import com.ylx.point.domain.vo.*;
import com.ylx.point.enums.PointActivityTypeEnum;
import com.ylx.point.service.IPointActivityTaskService;
import com.ylx.point.service.IPointSignRewardService;
import com.ylx.point.service.IPointSignTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ylx.point.domain.PointActivity;
import com.ylx.point.mapper.PointActivityMapper;
import com.ylx.point.service.IPointActivityService;
import org.springframework.transaction.annotation.Transactional;


/**
 * 积分活动主Service业务层处理
 *
 * @author wzj
 * @date 2026-03-25
 */
@Service
public class PointActivityServiceImpl implements IPointActivityService {
    @Autowired
    private PointActivityMapper pointActivityMapper;
    @Autowired
    private IPointActivityTaskService pointActivityTaskService;
    @Autowired
    private IPointSignTaskService pointSignTaskService;
    @Autowired
    private IPointSignRewardService pointSignRewardService;


    @Override
    public Page<PointActivityPageVo> page(Page<PointActivity> page, PointActivityPageDTO dto) {
        return null;
    }

    @Override
    public PointActivityDetailsVo<?> getDetailsInfo(Long id) {

        PointActivity pointActivity = this.pointActivityMapper.selectPointActivityById(id);
        if (ObjectUtil.isNull(pointActivity)) {
            return null;
        }

        Integer activityType = pointActivity.getActivityType();
        if (PointActivityTypeEnum.SIGN_TASK.getCode().equals(activityType)) {
            PointSignTaskVo vo = this.pointSignTaskService.selectPointSignTaskByActivityId(pointActivity.getId());
            BeanUtil.copyProperties(pointActivity, vo);
            return PointActivityDetailsVo.of(PointActivityTypeEnum.SIGN_TASK.getCode(), vo);
        } else if (PointActivityTypeEnum.ACTIVITY_TASK.getCode().equals(activityType)) {
            PointActivityTaskVo vo = new PointActivityTaskVo();
            BeanUtil.copyProperties(pointActivity, vo);
            List<PointActivityTaskDTO> activityTaskList = this.pointActivityTaskService.selectPointActivityTaskByActivityId(pointActivity.getId());
            vo.setActivityTaskList(activityTaskList);
            return PointActivityDetailsVo.of(PointActivityTypeEnum.ACTIVITY_TASK.getCode(), vo);
        }

        return PointActivityDetailsVo.of(activityType, new PointActivityBaseVo());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void add(PointActivityDTO dto) {

        // 校验参数
        validateActivityDTO(dto);

        // 保存活动信息
        PointActivity entity = createActivityEntity(dto);
        saveActivity(entity);

        // 保存活动详情信息
        saveActivityDetails(dto, entity.getId());

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void edit(PointActivityDTO dto) {

    }

    @Override
    public PointActivityStatVo getStatInfo(String id) {
        return null;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void editValidity(PointActivityValidityDTO dto) {

    }

    private void validateActivityDTO(PointActivityDTO dto) {
        if (ObjectUtil.isNull(dto)) {
            throw new BaseException("活动信息不能为空");
        }

        PointActivityDTO.ActivityTimeConfig timeConfig = dto.getTimeConfig();
        if (ObjectUtil.isNull(timeConfig) || (!timeConfig.isPermanent() &&
                (ObjectUtil.isNull(timeConfig.getStartTime()) || ObjectUtil.isNull(timeConfig.getEndTime())))) {
            throw new BaseException("活动时间配置不能为空");
        }
    }

    private PointActivity createActivityEntity(PointActivityDTO dto) {
        PointActivity entity = new PointActivity();
        BeanUtil.copyProperties(dto, entity);

        PointActivityDTO.ActivityTimeConfig timeConfig = dto.getTimeConfig();
        entity.setStartTime(DateUtil.beginOfDay(timeConfig.getStartTime()));
        
        // 处理endTime，确保时间部分正确设置为23:59:59
        Date endTime = timeConfig.getEndTime();
        if (endTime != null) {
            // 使用Java 8的日期时间API处理时区问题
            java.time.LocalDateTime localDateTime = java.time.LocalDateTime.ofInstant(
                endTime.toInstant(),
                java.time.ZoneId.systemDefault()
            );
            // 设置为当天的23:59:59
            java.time.LocalDateTime endOfDay = localDateTime.with(
                java.time.LocalTime.of(23, 59, 59)
            );
            // 转换回Date对象
            endTime = Date.from(
                endOfDay.atZone(java.time.ZoneId.systemDefault()).toInstant()
            );
        }
        entity.setEndTime(endTime);
        entity.setIsPermanent(timeConfig.isPermanent() ? 1 : 0);

        return entity;
    }

    private void saveActivity(PointActivity entity) {
        int affectedRows = pointActivityMapper.insertPointActivity(entity);
        if (affectedRows <= 0) {
            throw new BaseException("保存积分活动失败");
        }
    }

    private void saveActivityDetails(PointActivityDTO dto, Long activityId) {
        if (PointActivityTypeEnum.SIGN_TASK.getCode().equals(dto.getActivityType())) {
            saveSignTaskDetails(dto, activityId);
        } else if (PointActivityTypeEnum.ACTIVITY_TASK.getCode().equals(dto.getActivityType())) {
            saveActivityTaskDetails(dto, activityId);
        }
    }

    private void saveSignTaskDetails(PointActivityDTO dto, Long activityId) {
        PointSignTaskDTO signTaskDTO = dto.getSignTaskDTO();
        if (ObjectUtil.isNull(signTaskDTO)) {
            throw new BaseException("签到任务配置不能为空");
        }

        PointSignTask pointSignTask = new PointSignTask();
        pointSignTask.setActivityId(activityId);
        pointSignTask.setBasePoints(signTaskDTO.getBasePoints());
        pointSignTask.setBreakRule(signTaskDTO.getBreakRule());
        pointSignTask.setCreateTime(new Date());
        pointSignTask.setUpdateTime(pointSignTask.getCreateTime());
        pointSignTask.setIsDeleted(0);
        int affectedRows = pointSignTaskService.insertPointSignTask(pointSignTask);
        if (affectedRows <= 0) {
            throw new BaseException("保存积分签到任务规则失败");
        }

        saveSignRewards(signTaskDTO.getSignRewardList(), pointSignTask.getId());
    }

    private void saveSignRewards(List<PointSignRewardDTO> rewardList, Long taskId) {
        if (CollectionUtil.isEmpty(rewardList)) {
            return;
        }

        List<PointSignReward> rewards = rewardList.stream()
                .map(dto -> {
                    PointSignReward reward = new PointSignReward();
                    reward.setRewardPoints(dto.getRewardPoints());
                    reward.setContinueDays(dto.getContinueDays());
                    reward.setCreateTime(new Date());
                    reward.setUpdateTime(reward.getCreateTime());
                    reward.setIsDeleted(0);
                    reward.setSignTaskId(taskId);
                    return reward;
                })
                .collect(Collectors.toList());

        pointSignRewardService.batchInsertPointSignReward(rewards);
    }

    private void saveActivityTaskDetails(PointActivityDTO dto, Long activityId) {
        List<PointActivityTaskDTO> tasks = dto.getTasks();
        if (CollectionUtil.isEmpty(tasks)) {
            return;
        }

        List<PointActivityTask> activityTasks = tasks.stream()
                .map(task -> {
                    PointActivityTask activityTask = new PointActivityTask();
                    BeanUtil.copyProperties(task, activityTask);
                    activityTask.setActivityId(activityId);
                    activityTask.setIsDeleted(0);
                    activityTask.setCreateTime(new Date());
                    activityTask.setUpdateTime(activityTask.getCreateTime());
                    return activityTask;
                })
                .collect(Collectors.toList());

        pointActivityTaskService.batchInsertPointActivityTask(activityTasks);
    }
}