package cc.mrbird.febs.mall.service.impl;

import cc.mrbird.febs.common.entity.FebsResponse;
import cc.mrbird.febs.common.enumerates.StateUpDownEnum;
import cc.mrbird.febs.common.exception.FebsException;
import cc.mrbird.febs.common.utils.LoginUserUtil;
import cc.mrbird.febs.mall.entity.HappyActivity;
import cc.mrbird.febs.mall.entity.HappyActivityOption;
import cc.mrbird.febs.mall.entity.HappyFollow;
import cc.mrbird.febs.mall.entity.MallMember;
import cc.mrbird.febs.mall.mapper.HappyActivityMapper;
import cc.mrbird.febs.mall.mapper.HappyActivityOptionMapper;
import cc.mrbird.febs.mall.mapper.HappyFollowMapper;
import cc.mrbird.febs.mall.mapper.MallMemberMapper;
import cc.mrbird.febs.mall.service.HappyActivityService;
import cc.mrbird.febs.mall.vo.api.activity.*;
import cc.mrbird.febs.mall.vo.api.activity.follow.ApiOperateDoDto;
import cc.mrbird.febs.mall.vo.api.activity.options.*;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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 org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@Service
@RequiredArgsConstructor
@Transactional
public class HappyActivityServiceImpl extends ServiceImpl<HappyActivityMapper, HappyActivity> implements HappyActivityService {

    private final HappyFollowMapper happyFollowMapper;
    private final MallMemberMapper mallMemberMapper;
    private final HappyActivityOptionMapper happyActivityOptionMapper;

    @Override
    public FebsResponse activityList(ApiActivityInfoDto dto) {
        // 创建分页对象，传入当前页和每页大小
        Page<ApiActivityInfoVo> page = new Page<>(dto.getPageNow(), dto.getPageSize());
        // 调用Mapper方法获取活动分页数据
        Page<ApiActivityInfoVo> happyActivityPage = this.baseMapper.selectActivityPage(page, dto);

        // 检查分页结果是否包含数据
        if(CollUtil.isNotEmpty(happyActivityPage.getRecords())){
            List<ApiActivityInfoVo> records = happyActivityPage.getRecords();
            // 使用Stream流操作records，获取所有活动的ID
            List<Long> ids = records.stream().map(ApiActivityInfoVo::getId).collect(Collectors.toList());

            // 查询关注点赞转发记录，筛选出关注活动类型且未删除的关注记录，并按ID升序排序，限制结果数量为3
            List<HappyFollow> happyFollows = happyFollowMapper.selectList(
                    new LambdaQueryWrapper<HappyFollow>()
                            .select(HappyFollow::getMemberId)
                            .eq(HappyFollow::getSourceType, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode())
                            .in(HappyFollow::getSourceId, ids)
                            .eq(HappyFollow::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
                            .orderByAsc(HappyFollow::getId)
                            .last("limit 3")
            );

            // 检查关注记录是否不为空
            if(CollUtil.isNotEmpty(happyFollows)){
                // 使用Stream流操作关注记录，获取所有成员ID的集合
                Set<Long> memberIds = happyFollows.stream().collect(Collectors.mapping(HappyFollow::getMemberId, Collectors.toSet()));

                // 查询成员信息，获取成员的ID和头像
                List<MallMember> mallMembers = mallMemberMapper.selectList(
                        new LambdaQueryWrapper<MallMember>()
                                .select(MallMember::getId,MallMember::getAvatar)
                                .in(MallMember::getId, memberIds)
                );

                // 使用Stream流操作成员信息，生成一个以成员ID为键，成员信息为值的Map
                Map<Long, MallMember> memberMap = mallMembers.stream()
                        .collect(Collectors.toMap(MallMember::getId, member -> member));

                // 使用Stream流操作关注记录，生成一个以活动ID为键，成员ID列表为值的Map
                Map<Long, List<Long>> followMap = happyFollows.stream()
                        .collect(Collectors.groupingBy(
                                HappyFollow::getSourceId,
                                Collectors.mapping(HappyFollow::getMemberId, Collectors.toList())
                        ));

                // 遍历活动记录，为每个活动添加成员头像信息
                records.forEach(record -> {
                    List<Long> memberIdsForRecord = followMap.get(record.getId());
                    if (CollUtil.isNotEmpty(memberIdsForRecord)) {
                        List<String> memberAvatars = memberIdsForRecord.stream()
                                .map(memberMap::get)
                                .filter(member -> member != null)
                                .map(MallMember::getAvatar)
                                .collect(Collectors.toList());
                        record.setMemberAvatars(memberAvatars);
                    }
                });
            }
        }
        // 返回成功响应，包含活动分页数据
        return new FebsResponse().success().data(happyActivityPage);
    }

    @Override
    public FebsResponse activityInfo(ApiActivityDto dto) {

        ApiActivityVo apiActivityVo = new ApiActivityVo();
        HappyActivity happyActivity = this.baseMapper.selectOne(
                new LambdaQueryWrapper<HappyActivity>()
                        .eq(HappyActivity::getId, dto.getId())
                        .eq(HappyActivity::getType, dto.getType())
                        .eq(HappyActivity::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
                        .ne(HappyActivity::getState, StateUpDownEnum.ACTIVITY_STATE_NOT_START.getCode())
        );
        if(happyActivity != null){
            BeanUtil.copyProperties(happyActivity,apiActivityVo);
        }
        return new FebsResponse().success().data(apiActivityVo);
    }

    @Override
    public FebsResponse voteOptionList(Long id) {
        ArrayList<ApiActivityOptionListVo> apiActivityOptionListVos = new ArrayList<>();


        HappyActivity happyActivity = this.baseMapper.selectById(id);
        if(StateUpDownEnum.ACTIVITY_TYPE_VOTE.getCode() != happyActivity.getType()){
            throw new FebsException("投票活动才可获取投票选项");
        }

        List<HappyActivityOption> happyActivityOptions = happyActivityOptionMapper.selectList(
                new LambdaQueryWrapper<HappyActivityOption>()
                        .select(
                                HappyActivityOption::getId,
                                HappyActivityOption::getOptionName,
                                HappyActivityOption::getRank,
                                HappyActivityOption::getLikesCnt,
                                HappyActivityOption::getImage
                        )
                .eq(HappyActivityOption::getActivityId,id)
                .eq(HappyActivityOption::getState,StateUpDownEnum.VOTE_OPTION_STATE_AUDIT_SUCCESS.getCode())
                .eq(HappyActivityOption::getDeleteFlag,StateUpDownEnum.DOWN.getCode())
                .orderByAsc(HappyActivityOption::getRank)
        );
        if(CollUtil.isNotEmpty(happyActivityOptions)){
            happyActivityOptions.forEach(option -> {
                ApiActivityOptionListVo apiActivityOptionListVo = new ApiActivityOptionListVo();
                BeanUtil.copyProperties(option, apiActivityOptionListVo);
                apiActivityOptionListVos.add(apiActivityOptionListVo);
            });
        }
        return new FebsResponse().success().data(apiActivityOptionListVos);
    }

    @Override
    public FebsResponse voteOption(Long id) {

        ApiActivityOptionVo apiActivityOptionVo = new ApiActivityOptionVo();
        HappyActivityOption happyActivityOption = happyActivityOptionMapper.selectById(id);
        if(happyActivityOption != null){
            BeanUtil.copyProperties(happyActivityOption, apiActivityOptionVo);
        }
        return new FebsResponse().success().data(apiActivityOptionVo);
    }

    @Override
    public FebsResponse operateDo(ApiOperateDoDto dto) {
        Long memberId = LoginUserUtil.getLoginUser().getId();
        Integer sourceType = dto.getSourceType();
        Long sourceId = dto.getSourceId();
        Integer type = dto.getType();

        try {
            if (StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode() == sourceType) {
                // 活动点赞或关注
                HappyActivity happyActivity = this.baseMapper.selectById(sourceId);
                if (happyActivity == null) {
                    throw new FebsException("活动不存在");
                }

                if (StateUpDownEnum.ACTIVITY_TYPE_VOTE.getCode() == happyActivity.getType()) {
                    Long sourceOptionId = dto.getSourceOptionId();
                    if (sourceOptionId == null) {
                        throw new FebsException("选项ID不能为空");
                    }
                    this.operateDoVote(memberId, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode(), sourceId, sourceOptionId, type);
                } else {
                    this.operateDo(memberId, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode(), sourceId, type);
                }
            } else if (StateUpDownEnum.SOURCE_TYPE_SOCIAL_CIRCLE.getCode() == sourceType) {
                // 朋友圈点赞或关注
                this.operateDo(memberId, StateUpDownEnum.SOURCE_TYPE_SOCIAL_CIRCLE.getCode(), sourceId, type);
            } else {
                throw new FebsException("不支持的操作类型");
            }
        } catch (Exception e) {
            // 捕获异常并返回错误信息
            log.error("操作失败：{}", e.getMessage());
            throw new FebsException("操作失败");
        }
        return new FebsResponse().success();
    }

    @Override
    public void operateDoVote(Long memberId, int code, Long sourceId, Long sourceOptionId, Integer type) {
        HappyFollow happyFollow = new HappyFollow();
        happyFollow.setMemberId(memberId);
        happyFollow.setSourceType(code);
        happyFollow.setSourceId(sourceId);
        happyFollow.setSourceOptionId(sourceOptionId);
        happyFollow.setType(type);
        happyFollowMapper.insert(happyFollow);
    }

    @Override
    public void operateDo(Long memberId, int code, Long sourceId, Integer type) {
        HappyFollow happyFollow = new HappyFollow();
        happyFollow.setMemberId(memberId);
        happyFollow.setSourceType(code);
        happyFollow.setSourceId(sourceId);
        happyFollow.setType(type);
        happyFollowMapper.insert(happyFollow);
    }

    @Override
    public FebsResponse operateVote(ApiOperateVoteDto dto) {
        Long memberId = LoginUserUtil.getLoginUser().getId();
        Long sourceId = dto.getSourceId();
        Long sourceOptionId = dto.getSourceOptionId();
        Integer sourceType = dto.getSourceType();
        Integer type = StateUpDownEnum.VOTE.getCode();

        //验证当前登录人员今日是否已经投票
        List<HappyFollow> happyFollows = happyFollowMapper.selectList(
                new LambdaQueryWrapper<HappyFollow>()
                        .eq(HappyFollow::getMemberId, memberId)
                        .eq(HappyFollow::getSourceId, sourceId)
                        .eq(HappyFollow::getSourceOptionId, sourceOptionId)
                        .eq(HappyFollow::getType, type)
                        .gt(HappyFollow::getCreatedTime, DateUtil.beginOfDay(new Date()))
        );
        if (CollUtil.isNotEmpty(happyFollows)){
            throw new FebsException("今日已经投票");
        }

        if (StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode() == sourceType) {
            HappyActivityOption happyActivityOption = happyActivityOptionMapper.selectById(sourceOptionId);
            if (happyActivityOption == null) {
                throw new FebsException("投票对象不存在");
            }
            if (StateUpDownEnum.VOTE_OPTION_STATE_AUDIT_SUCCESS.getCode() != happyActivityOption.getState()) {
                throw new FebsException("请重新选择投票对象");
            }

            Integer likesCnt = happyActivityOption.getLikesCnt();
            if (likesCnt == null) {
                likesCnt = 0;
            }
            likesCnt += 1;
            happyActivityOption.setLikesCnt(likesCnt);

            boolean updateSuccess = happyActivityOptionMapper.updateById(happyActivityOption) > 0;
            if (!updateSuccess) {
                throw new FebsException("更新票数失败");
            }

            this.operateDoVote(memberId, sourceType, sourceId, sourceOptionId, type);
        }
        return new FebsResponse().success();
    }

    @Override
    public FebsResponse voteRecordInPage(ApiVoteRecordInPageDto dto) {
        // 创建分页对象，传入当前页和每页大小
        Page<ApiActivityInfoVo> page = new Page<>(dto.getPageNow(), dto.getPageSize());
        Page<ApiVoteRecordInPageVo> voteRecordInPage = this.baseMapper.getVoteRecordInPage(page, dto);

        List<ApiVoteRecordInPageVo> records = voteRecordInPage.getRecords();
        if(CollUtil.isNotEmpty(records)){
            //stream流操作records，获取全部的memberId(全部投票人)
            Set<Long> memberIds = records.stream().map(ApiVoteRecordInPageVo::getMemberId).collect(Collectors.toSet());
            if(CollUtil.isEmpty(memberIds)){
                List<MallMember> mallMembers = mallMemberMapper.selectList(
                        new LambdaQueryWrapper<MallMember>()
                                .select(MallMember::getId, MallMember::getName, MallMember::getAvatar)
                                .in(MallMember::getId,memberIds)
                );
                //stream流操作mallMembers得到一个Map<memberId,MallMember>的map对象
                Map<Long, MallMember> mallMemberMap = mallMembers.stream().collect(Collectors.toMap(MallMember::getId, mallMember -> mallMember));
                records.forEach(record -> {
                    MallMember mallMember = mallMemberMap.get(record.getMemberId());
                    record.setName(mallMember.getName());
                    record.setAvatar(mallMember.getAvatar());
                });
            }
        }



        return new FebsResponse().success().data(voteRecordInPage);
    }

    @Override
    public FebsResponse operateRegister(ApiOperateRegisterActivityDto dto) {
        return null;
    }

    public static void main(String[] args) {
        Date date = new Date();
        //获取今日的凌晨的时间
        DateTime dateTime = DateUtil.beginOfDay(date);
        System.out.println(dateTime);
    }
}