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

import cc.mrbird.febs.common.entity.FebsResponse;
import cc.mrbird.febs.common.entity.QueryRequest;
import cc.mrbird.febs.common.enumerates.StateUpDownEnum;
import cc.mrbird.febs.common.utils.MallUtils;
import cc.mrbird.febs.mall.dto.AdminHappyActivityCategoryDto;
import cc.mrbird.febs.mall.dto.activity.*;
import cc.mrbird.febs.mall.entity.*;
import cc.mrbird.febs.mall.mapper.*;
import cc.mrbird.febs.mall.service.IAdminHappyActivityService;
import cc.mrbird.febs.mall.vo.AdminMallGoodsCommentVo;
import cc.mrbird.febs.mall.vo.activity.AdminActivityCommentVo;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
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.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

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

    private final HappyActivityCategoryMapper happyActivityCategoryMapper;
    private final HappyActivityOptionMapper happyActivityOptionMapper;
    private final HappyActivityOrderMapper happyActivityOrderMapper;
    private final HappyActivityCommentMapper happyActivityCommentMapper;
    private final HappyActivityOrderItemMapper happyActivityOrderItemMapper;
    private final HappyFollowMapper happyFollowMapper;
    private final MallMemberMapper mallMemberMapper;

    @Override
    public IPage<HappyActivityCategory> getGroupList(AdminHappyActivityCategoryDto dto, QueryRequest request) {
        Page<HappyActivityCategory> page = new Page<>(request.getPageNum(), request.getPageSize());
        LambdaQueryWrapper<HappyActivityCategory> voteOptionLambdaQueryWrapper = new LambdaQueryWrapper<>();
        if(StrUtil.isNotEmpty(dto.getName())){
            voteOptionLambdaQueryWrapper.eq(HappyActivityCategory::getName,dto.getName());
        }
        if(ObjectUtil.isNotEmpty(dto.getStatus())){
            voteOptionLambdaQueryWrapper.eq(HappyActivityCategory::getState,dto.getStatus());
        }
        if(ObjectUtil.isNotEmpty(dto.getHotState())){
            voteOptionLambdaQueryWrapper.eq(HappyActivityCategory::getHotState,dto.getHotState());
        }
        voteOptionLambdaQueryWrapper.eq(HappyActivityCategory::getDeleteFlag, StateUpDownEnum.DOWN.getCode());
        voteOptionLambdaQueryWrapper.orderByDesc(HappyActivityCategory::getCreatedTime);
        Page<HappyActivityCategory> adminOptionVoIPage = happyActivityCategoryMapper.selectPage(page, voteOptionLambdaQueryWrapper);
        return adminOptionVoIPage;
    }

    @Override
    public FebsResponse addGroup(AdminCategoryAddDto dto) {

        HappyActivityCategory happyActivityCategory = new HappyActivityCategory();
        happyActivityCategory.setName(dto.getName());
        happyActivityCategory.setOrderCnt(dto.getOrderCnt());
        happyActivityCategoryMapper.insert(happyActivityCategory);
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse groupDelete(Long id) {
        HappyActivityCategory happyActivityCategory = happyActivityCategoryMapper.selectById(id);
        happyActivityCategory.setDeleteFlag(StateUpDownEnum.UP.getCode());
        happyActivityCategoryMapper.updateById(happyActivityCategory);
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse groupUpdate(AdminCategoryUpdateDto dto) {

        HappyActivityCategory happyActivityCategory = happyActivityCategoryMapper.selectById(dto.getId());
        happyActivityCategory.setName(dto.getName());
        happyActivityCategory.setOrderCnt(dto.getOrderCnt());
        happyActivityCategoryMapper.updateById(happyActivityCategory);
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse groupState(Long id, Integer type) {

        HappyActivityCategory happyActivityCategory = happyActivityCategoryMapper.selectById(id);
        if(StateUpDownEnum.UP.getCode() == happyActivityCategory.getDeleteFlag()){
            throw new RuntimeException("该分组已删除，无法操作");
        }

        if(type == 1){
            happyActivityCategory.setHotState(happyActivityCategory.getHotState() == StateUpDownEnum.UP.getCode() ? StateUpDownEnum.DOWN.getCode() : StateUpDownEnum.UP.getCode());
        }

        if(type == 2){
            happyActivityCategory.setState(happyActivityCategory.getState() == StateUpDownEnum.UP.getCode() ? StateUpDownEnum.DOWN.getCode() : StateUpDownEnum.UP.getCode());
        }
        happyActivityCategoryMapper.updateById(happyActivityCategory);
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public List<HappyActivityCategory> allGroup() {
        List<HappyActivityCategory> happyActivityCategories =
                happyActivityCategoryMapper.selectList(
                        new LambdaQueryWrapper<HappyActivityCategory>()
                                .eq(HappyActivityCategory::getState, StateUpDownEnum.UP.getCode())
                                .eq(HappyActivityCategory::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
                                .orderByDesc(HappyActivityCategory::getOrderCnt)
                );
        if(CollUtil.isNotEmpty(happyActivityCategories)){
            return happyActivityCategories;
        }
        return Collections.emptyList();
    }

    @Override
    public IPage<HappyActivity> getAdminActivityListInPage(HappyActivity dto, QueryRequest request) {
        Page<HappyActivity> page = new Page<>(request.getPageNum(), request.getPageSize());
        LambdaQueryWrapper<HappyActivity> voteActivityLambdaQueryWrapper = new LambdaQueryWrapper<>();
        if(StrUtil.isNotEmpty(dto.getName())){
            voteActivityLambdaQueryWrapper.like(HappyActivity::getName,dto.getName());
        }
        if(ObjectUtil.isNotEmpty(dto.getState())){
            voteActivityLambdaQueryWrapper.eq(HappyActivity::getState,dto.getState());
        }

        if(ObjectUtil.isNotEmpty(dto.getCategoryId())){
            voteActivityLambdaQueryWrapper.eq(HappyActivity::getCategoryId,dto.getCategoryId());
        }
        voteActivityLambdaQueryWrapper.eq(HappyActivity::getDeleteFlag, StateUpDownEnum.DOWN.getCode());
        voteActivityLambdaQueryWrapper.orderByDesc(HappyActivity::getCreatedTime);
        Page<HappyActivity> voteActivityPage = this.baseMapper.selectPage(page, voteActivityLambdaQueryWrapper);

        List<HappyActivity> records = voteActivityPage.getRecords();
        if(CollUtil.isNotEmpty(records)){
            //stream流获取records的全部categoryId
            Set<Long> categoryIds = records.stream().map(HappyActivity::getCategoryId).collect(Collectors.toSet());
            if(CollUtil.isNotEmpty(categoryIds)){
                //stream流操作categoryIds得到一个Map<categoryId,HappyActivityCategory>的map对象
                List<HappyActivityCategory> happyActivityCategories = happyActivityCategoryMapper.selectList(
                        new LambdaQueryWrapper<HappyActivityCategory>()
                                .select(HappyActivityCategory::getId, HappyActivityCategory::getName)
                                .in(HappyActivityCategory::getId,categoryIds)
                );
                Map<Long, HappyActivityCategory> categoryMap = happyActivityCategories.stream().collect(Collectors.toMap(HappyActivityCategory::getId, happyActivityCategory -> happyActivityCategory));

                for (HappyActivity happyActivity : records){
                    happyActivity.setCategoryName(categoryMap.get(happyActivity.getCategoryId()).getName());
                }
            }
        }
        return voteActivityPage;
    }

    @Override
    public FebsResponse addActivity(HappyActivity dto) {

        String code = MallUtils.getOrderNum("AC");

        HappyActivity happyActivity = new HappyActivity();
        BeanUtil.copyProperties(dto, happyActivity);
        happyActivity.setCode(code);
        happyActivity.setExpectCnt(dto.getJoinCnt());
        happyActivity.setSurplusCnt(dto.getJoinCnt());
        this.baseMapper.insert(happyActivity);

        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse delActivity(Long id) {
        HappyActivity happyActivity = this.baseMapper.selectById(id);

        happyActivity.setDeleteFlag(StateUpDownEnum.UP.getCode());
        this.baseMapper.updateById(happyActivity);

        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse changeState(Long id, Integer state) {
        HappyActivity happyActivity = this.baseMapper.selectById(id);

        happyActivity.setState(state);
        this.baseMapper.updateById(happyActivity);

        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse activityUpdate(HappyActivity dto) {

        HappyActivity happyActivity = this.baseMapper.selectById(dto.getId());
        happyActivity.setCategoryId(dto.getCategoryId());
        happyActivity.setName(dto.getName());
        happyActivity.setType(dto.getType());
        happyActivity.setJoinCnt(dto.getJoinCnt());
        happyActivity.setExpectCnt(dto.getJoinCnt());
        happyActivity.setSurplusCnt(dto.getSurplusCnt());
        happyActivity.setStartTime(dto.getStartTime());
        happyActivity.setEndTime(dto.getEndTime());
        happyActivity.setPhone(dto.getPhone());
        happyActivity.setAddress(dto.getAddress());
        happyActivity.setPayState(dto.getPayState());
        happyActivity.setPayAmount(dto.getPayAmount());
        happyActivity.setTextRemark(dto.getTextRemark());
        happyActivity.setIndexImg(dto.getIndexImg());
        happyActivity.setOrderCnt(dto.getOrderCnt());
        happyActivity.setHotState(dto.getHotState());
        happyActivity.setBackImg(dto.getBackImg());
        happyActivity.setVoteCnt(dto.getVoteCnt());
        happyActivity.setAddState(dto.getAddState());
        this.baseMapper.updateById(happyActivity);

        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public IPage<HappyActivityOption> getOptionListInPage(HappyActivityOption dto, QueryRequest request) {
        List<HappyActivity> happyActivities = this.baseMapper.selectList(
                new LambdaQueryWrapper<HappyActivity>()
                        .select(HappyActivity::getId)
                        .eq(HappyActivity::getType, StateUpDownEnum.ACTIVITY_TYPE_VOTE.getCode())
        );
        if(CollUtil.isEmpty(happyActivities)){
            return new Page<>();
        }

        //stream流操作happyActivities得到一个set<id>集合
        Set<Long> activityIds = happyActivities.stream().map(HappyActivity::getId).collect(Collectors.toSet());

        Page<HappyActivityOption> page = new Page<>(request.getPageNum(), request.getPageSize());
        LambdaQueryWrapper<HappyActivityOption> voteOptionLambdaQueryWrapper = new LambdaQueryWrapper<>();
        if(ObjectUtil.isNotEmpty(dto.getActivityId())){
            voteOptionLambdaQueryWrapper.eq(HappyActivityOption::getActivityId,dto.getActivityId());
        }
        if(ObjectUtil.isNotEmpty(dto.getState())){
            voteOptionLambdaQueryWrapper.eq(HappyActivityOption::getState,dto.getState());
        }
        if(ObjectUtil.isNotEmpty(dto.getOptionName())){
            voteOptionLambdaQueryWrapper.eq(HappyActivityOption::getOptionName,dto.getOptionName());
        }
        voteOptionLambdaQueryWrapper.in(HappyActivityOption::getActivityId,activityIds);
        voteOptionLambdaQueryWrapper.eq(HappyActivityOption::getDeleteFlag, StateUpDownEnum.DOWN.getCode());
        voteOptionLambdaQueryWrapper.orderByDesc(HappyActivityOption::getCreatedTime);
        Page<HappyActivityOption> adminOptionVoIPage = happyActivityOptionMapper.selectPage(page, voteOptionLambdaQueryWrapper);
        return adminOptionVoIPage;
    }

    @Override
    public List<HappyActivity> allActivities() {
        List<HappyActivity> happyActivities = this.baseMapper.selectList(
                new LambdaQueryWrapper<HappyActivity>()
                        .select(HappyActivity::getId, HappyActivity::getName)
                        .eq(HappyActivity::getType, StateUpDownEnum.ACTIVITY_TYPE_VOTE.getCode())
                        .eq(HappyActivity::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
        );
        return happyActivities;
    }

    @Override
    public List<HappyActivity> allOrderActivities() {
        List<HappyActivity> happyActivities = this.baseMapper.selectList(
                new LambdaQueryWrapper<HappyActivity>()
                        .select(HappyActivity::getId, HappyActivity::getName)
                        .eq(HappyActivity::getPayState, StateUpDownEnum.ACTIVITY_CROWDFUNDING_STATE_OPEN.getCode())
                        .eq(HappyActivity::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
        );
        return happyActivities;
    }

    @Override
    public FebsResponse addOption(AdminActivityOptionAddDto dto) {


        if(ObjectUtil.isEmpty(dto.getActivityId())){
            return new FebsResponse().fail().message("请选择投票活动");
        }

        Integer optionCnt = happyActivityOptionMapper.selectCount(
                new LambdaQueryWrapper<HappyActivityOption>()
                        .eq(HappyActivityOption::getActivityId, dto.getActivityId())
                        .eq(HappyActivityOption::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
        );

        HappyActivityOption happyActivityOption = new HappyActivityOption();
        BeanUtil.copyProperties(dto, happyActivityOption);

        happyActivityOption.setOrderCnt(optionCnt + 1);
        happyActivityOptionMapper.insert(happyActivityOption);
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse optionUpdate(HappyActivityOption dto) {

        HappyActivityOption happyActivityOption = happyActivityOptionMapper.selectById(dto.getId());
        BeanUtil.copyProperties(dto, happyActivityOption);
        happyActivityOptionMapper.updateById(happyActivityOption);
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse optionDelete(Long id) {

        HappyActivityOption happyActivityOption = happyActivityOptionMapper.selectById(id);

        happyActivityOption.setDeleteFlag(StateUpDownEnum.UP.getCode());
        happyActivityOptionMapper.updateById(happyActivityOption);
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public IPage<HappyFollow> getFollowVoteInPage(HappyActivityOption voteRecord, QueryRequest request) {
        Long id = voteRecord.getId();
        HappyActivityOption happyActivityOption = happyActivityOptionMapper.selectById(id);
        if(ObjectUtil.isEmpty(happyActivityOption)){
            return null;
        }
        HappyActivity happyActivity = this.baseMapper.selectById(happyActivityOption.getActivityId());
        if(ObjectUtil.isEmpty(happyActivity)){
            return null;
        }
        //获取活动名称
        String activityName = happyActivity.getName();

        //获取选项名称
        String optionName = happyActivityOption.getOptionName();

        Page<HappyFollow> page = new Page<>(request.getPageNum(), request.getPageSize());
        LambdaQueryWrapper<HappyFollow> voteRecordLambdaQueryWrapper = new LambdaQueryWrapper<>();
        voteRecordLambdaQueryWrapper.eq(HappyFollow::getSourceId, happyActivity.getId());
        voteRecordLambdaQueryWrapper.eq(HappyFollow::getSourceOptionId, happyActivityOption.getId());
        voteRecordLambdaQueryWrapper.eq(HappyFollow::getType,StateUpDownEnum.VOTE.getCode());
        voteRecordLambdaQueryWrapper.orderByDesc(HappyFollow::getCreatedTime);
        Page<HappyFollow> adminIPage = happyFollowMapper.selectPage(page, voteRecordLambdaQueryWrapper);
        if(CollUtil.isNotEmpty(adminIPage.getRecords())){
            List<HappyFollow> records = adminIPage.getRecords();
            //stream流获取records的memberId的set集合
            Set<Long> memberIds = records.stream().map(HappyFollow::getMemberId).collect(Collectors.toSet());
            List<MallMember> mallMembers = mallMemberMapper.selectList(new LambdaQueryWrapper<MallMember>().in(MallMember::getId, memberIds));
            Map<Long, MallMember> mallMemberMap = mallMembers.stream().collect(Collectors.toMap(MallMember::getId, mallMember -> mallMember));
            for(HappyFollow record : records){
                record.setActivityName(activityName);
                record.setOptionName(optionName);
                String memberName = mallMemberMap.get(record.getMemberId()).getName();
                record.setMemberName(StrUtil.isEmpty(memberName) ? "未知用户" : memberName);
            }
        }
        return adminIPage;
    }

    @Override
    public IPage<HappyActivityOrder> activityOrderList(AdminHappyActivityOrderDto dto, QueryRequest request) {
        Page<HappyActivityOrder> page = new Page<>(request.getPageNum(), request.getPageSize());
        Page<HappyActivityOrder> adminOptionVoIPage = this.baseMapper.selectOrderInPage(page, dto);
        return adminOptionVoIPage;
    }

    @Override
    public FebsResponse checkOrder(AdminHappyActivityCheckOrderDto dto) {

        List<Long> ids = dto.getIds();
        if (CollUtil.isEmpty(ids)){
            return new FebsResponse().fail().message("请选择需要核销的订单");
        }
        for(Long id : ids){
            HappyActivityOrder happyActivityOrder = happyActivityOrderMapper.selectById(id);
            if(StateUpDownEnum.ORDER_STATE_WAIT_USE.getCode() == happyActivityOrder.getState()){
                happyActivityOrder.setState(StateUpDownEnum.ORDER_STATE_USED.getCode());
                happyActivityOrderMapper.updateById(happyActivityOrder);

                List<HappyActivityOrderItem> happyActivityOrderItems = happyActivityOrderItemMapper.selectList(
                        new LambdaQueryWrapper<HappyActivityOrderItem>()
                                .eq(HappyActivityOrderItem::getOrderId, id)
                );
                if(CollUtil.isNotEmpty(happyActivityOrderItems)){
                    happyActivityOrderItems.forEach(happyActivityOrderItem -> {
                        happyActivityOrderItem.setState(StateUpDownEnum.UP.getCode());
                        happyActivityOrderItemMapper.updateById(happyActivityOrderItem);
                    });
                }
            }
        }

        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse activityOrderDel(Long id) {

        HappyActivityOrder happyActivityOrder = happyActivityOrderMapper.selectById(id);
        if(ObjectUtil.isNotEmpty(happyActivityOrder)){
            happyActivityOrder.setDeleteFlag(StateUpDownEnum.UP.getCode());
            happyActivityOrderMapper.updateById(happyActivityOrder);
        }

        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public List<HappyActivityOption> getVoteOptionListForExport(Map<String, String> params) {
        LambdaQueryWrapper<HappyActivityOption> queryWrapper = new LambdaQueryWrapper<>();
        if(ObjectUtil.isNotEmpty(params.get("activityId"))){
            queryWrapper.eq(HappyActivityOption::getActivityId, Long.valueOf(params.get("activityId")));
        }
        if(ObjectUtil.isNotEmpty(params.get("audit"))){
            queryWrapper.eq(HappyActivityOption::getState, Integer.valueOf(params.get("state")));
        }
        if(ObjectUtil.isNotEmpty(params.get("beautyName"))){
            queryWrapper.like(HappyActivityOption::getOptionName, params.get("optionName"));
        }
        return happyActivityOptionMapper.selectList(queryWrapper);
    }

    @Override
    public IPage<AdminActivityCommentVo> getCommentListInPage(AdminActivityCommentDto dto, QueryRequest request) {
        Page<AdminActivityCommentVo> page = new Page<>(request.getPageNum(), request.getPageSize());
        IPage<AdminActivityCommentVo> adminActivityCommentVoIPage = this.baseMapper.getCommentListInPage(page, dto);
        return adminActivityCommentVoIPage;
    }

    @Override
    public FebsResponse showStateSwitchOn(Long id) {

        HappyActivityComment happyActivityComment = happyActivityCommentMapper.selectById(id);
        Integer showState = StateUpDownEnum.UP.getCode() == happyActivityComment.getShowState() ? StateUpDownEnum.DOWN.getCode() : StateUpDownEnum.UP.getCode();
        happyActivityComment.setShowState(showState);
        happyActivityCommentMapper.updateById(happyActivityComment);
        return new FebsResponse().success().message("操作成功");
    }
}