package com.doumee.service.business.impl;

import com.alibaba.fastjson.JSON;
import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.MultifileMapper;
import com.doumee.dao.business.ShopCommentJoinMapper;
import com.doumee.dao.business.ShopCommentMapper;
import com.doumee.dao.business.model.*;
import com.doumee.dao.web.dto.MultiFileDTO;
import com.doumee.dao.web.dto.ZanDTO;
import com.doumee.dao.web.dto.shop.*;
import com.doumee.service.business.MultifileService;
import com.doumee.service.business.ShopCommentService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.doumee.service.business.ZanService;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

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

/**
 * 商家评论管理信息表Service实现
 * @author 江蹄蹄
 * @date 2023/03/21 15:48
 */
@Service
public class ShopCommentServiceImpl implements ShopCommentService {

    @Autowired
    private ShopCommentMapper shopCommentMapper;

    @Autowired
    private ShopCommentJoinMapper shopCommentJoinMapper;

    @Autowired
    private SystemDictDataBiz systemDictDataBiz;

    @Autowired
    private MultifileMapper multifileMapper;

    @Autowired
    private MultifileService multifileService;

    @Autowired
    private ZanService zanService;

    @Override
    public Integer create(ShopCommentDTO shopComment) {
        LoginUserInfo userInfo = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();

        Date now = new Date();
        ShopComment comment = new ShopComment();
        comment.setCreator(userInfo.getId());
        comment.setCreateDate(now);
        comment.setEditor(userInfo.getId());
        comment.setEditDate(now);
        comment.setIsdeleted(Constants.ZERO);
        comment.setRemark(shopComment.getRemark());
        comment.setMemberId(userInfo.getMemberId());
        comment.setObjId(shopComment.getObjId());
        comment.setScore(shopComment.getScore());
        comment.setContent(shopComment.getContent());
        comment.setAnonymous(shopComment.getAnonymous());
        comment.setEnvScore(shopComment.getEnvScore());
        comment.setServiceScore(shopComment.getServiceScore());
        comment.setMenuIds(JSON.toJSONString(shopComment.getMenuIds()));
        comment.setStatus(Constants.ZERO);
        shopCommentMapper.insert(comment);

        if (!CollectionUtils.isEmpty(shopComment.getFileList())){

            shopComment.getFileList().forEach(s->{
                Multifile multifile = new Multifile();
                multifile.setCreator(userInfo.getId());
                multifile.setCreateDate(now);
                multifile.setEditor(userInfo.getId());
                multifile.setEditDate(now);
                multifile.setName(s.getName());
                multifile.setInfo(s.getInfo());
                multifile.setObjId(comment.getId());
                multifile.setType(s.getType());
                multifile.setObjType(Constants.TWO);
                multifile.setFileurl(s.getFileurl());
                multifile.setSortnum(s.getSortnum());
                multifileService.create(multifile);
            });
        }
        return comment.getId();
    }

    @Override
    public void deleteById(Integer id) {
        shopCommentMapper.deleteById(id);
    }

    @Override
    public void delete(ShopComment shopComment) {
        UpdateWrapper<ShopComment> deleteWrapper = new UpdateWrapper<>(shopComment);
        shopCommentMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        shopCommentMapper.deleteBatchIds(ids);
    }

    @Override
    public void updateById(ShopComment shopComment) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();

        shopComment.setEditor(user.getId());
        shopComment.setEditDate(new Date());
        shopCommentMapper.updateById(shopComment);
    }

    @Override
    public void updateByIdInBatch(List<ShopComment> shopComments) {
        if (CollectionUtils.isEmpty(shopComments)) {
            return;
        }
        for (ShopComment shopComment: shopComments) {
            this.updateById(shopComment);
        }
    }

    @Override
    public ShopComment findById(Integer id) {
        return shopCommentMapper.selectById(id);
    }

    @Override
    public ShopComment findOne(ShopComment shopComment) {
        QueryWrapper<ShopComment> wrapper = new QueryWrapper<>(shopComment);
        return shopCommentMapper.selectOne(wrapper);
    }

    @Override
    public List<ShopComment> findList(ShopComment shopComment) {
        QueryWrapper<ShopComment> wrapper = new QueryWrapper<>(shopComment);
        return shopCommentMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<ShopComment> findPage(PageWrap<ShopComment> pageWrap) {
        IPage<ShopComment> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        MPJLambdaWrapper<ShopComment> queryWrapper = new MPJLambdaWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());

        queryWrapper.selectAll(ShopComment.class);
        queryWrapper.selectAs(Member::getNickname,ShopComment::getNikeName);
        queryWrapper.selectAs(Shop::getName,ShopComment::getShopName);


        queryWrapper.leftJoin(Member.class,Member::getId,ShopComment::getMemberId);
        queryWrapper.leftJoin(Shop.class,Shop::getId,ShopComment::getObjId);

        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getShopName()),Shop::getName,pageWrap.getModel().getShopName());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getNikeName()),Member::getNickname,pageWrap.getModel().getNikeName());
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getContent()),ShopComment::getContent,pageWrap.getModel().getContent());
        queryWrapper.orderByDesc(ShopComment::getCreateDate);
        IPage<ShopComment> result = shopCommentJoinMapper.selectJoinPage(page, ShopComment.class, queryWrapper);

        String path = systemDictDataBiz.queryByCode(Constants.OSS, Constants.RESOURCE_PATH).getCode() + systemDictDataBiz.queryByCode(Constants.OSS, Constants.ACTIVITY_FILE).getCode();
        for (ShopComment model : result.getRecords()) {
            Multifile queryfile = new Multifile();
            queryfile.setObjId(model.getId());
            queryfile.setObjType(Constants.MultiFile.SHOP_APPRAISE.getKey());
            List<Multifile> filelist = multifileMapper.selectList(new QueryWrapper<>(queryfile)
            .orderByAsc("SORTNUM")
            );
            filelist.stream().forEach(s ->{
                if(StringUtils.isNotBlank(s.getFileurl())){
                    s.setFileFullUrl(path+s.getFileurl());
                }
            });
            model.setFileList(filelist);
        }
        return PageData.from(result);
    }

    @Override
    public long count(ShopComment shopComment) {
        QueryWrapper<ShopComment> wrapper = new QueryWrapper<>(shopComment);
        return shopCommentMapper.selectCount(wrapper);
    }

    @Override
    public long count(Date start, Date end, Integer memberId, Integer type) {
        QueryWrapper<ShopComment> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(ShopComment::getMemberId,memberId)
                .eq(Objects.nonNull(type),ShopComment::getType,type)
                .between(ShopComment::getCreateDate,start,end);
        return shopCommentMapper.selectCount(wrapper);
    }

    @Override
    public ShopComment findAvg(Integer shopId) {
        QueryWrapper<ShopComment> wrapper = new QueryWrapper<>();
        wrapper.select("avg(score) as score,avg(envScore) as envScore,avg(serviceScore) as serviceScore");
        wrapper.lambda().eq(ShopComment::getObjId,shopId);
        return shopCommentMapper.selectOne(wrapper.last(" limit 1"));
    }

    @Override
    public List<ShopComment> getAvgs(List<Integer> shopIds) {


        QueryWrapper<ShopComment> wrapper = new QueryWrapper<>();
        wrapper.select("avg(score) as score,avg(ENV_SCORE) as envScore,avg(SERVICE_SCORE) as serviceScore,OBJ_ID");
        wrapper.lambda().in(ShopComment::getObjId,shopIds)
                        .groupBy(ShopComment::getObjId);
        List<ShopComment> shopComments = shopCommentMapper.selectList(wrapper);
        return shopComments;
    }

    @Override
    public PageData<ShopCommentDTO> findShopCommentDTOPage(PageWrap<ShopComment> pageWrap) {
        IPage<ShopComment> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        MPJLambdaWrapper<ShopComment> queryWrapper = new MPJLambdaWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());

        queryWrapper.selectAll(ShopComment.class);
        queryWrapper.selectAs(Member::getNickname,ShopCommentDTO::getNikeName);
        queryWrapper.selectAs(Member::getImgurl,ShopCommentDTO::getImgurl);

        queryWrapper.leftJoin(Member.class,Member::getId,ShopComment::getMemberId);
        queryWrapper.eq(Objects.nonNull(pageWrap.getModel().getObjId()),ShopComment::getObjId,pageWrap.getModel().getObjId());
        queryWrapper.eq(ShopComment::getIsdeleted,Constants.ZERO);
        queryWrapper.eq(ShopComment::getStatus,Constants.ZERO);
        queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getMenuIds()),
                                                    ShopComment::getMenuIds,
                                                    pageWrap.getModel().getMenuIds());

        queryWrapper.orderByDesc(ShopComment::getCreateDate);
        IPage<ShopCommentDTO> result = shopCommentJoinMapper.selectJoinPage(page, ShopCommentDTO.class, queryWrapper);

        String path = systemDictDataBiz.queryByCode(Constants.OSS, Constants.RESOURCE_PATH).getCode()
                + systemDictDataBiz.queryByCode(Constants.OSS, Constants.COMMENT_FILE).getCode();
        List<Integer> shopCommentIds = result.getRecords().stream().map(s -> s.getId()).collect(Collectors.toList());

        Map<Integer, List<MultiFileDTO>> objFileUrl = multifileService.getOBJFileUrl(shopCommentIds, Constants.MultiFile.SHOP_APPRAISE.getKey(),Constants.SHOP_FILE);

        Map<Integer, ZanDTO> count = zanService.count(shopCommentIds);

        for (ShopCommentDTO model : result.getRecords()) {

            ZanDTO zanDTO = MapUtils.getObject(count, model.getId());
            model.setZanCount(zanDTO != null ? zanDTO.getCount() : 0);

            List<MultiFileDTO> multiFileDTOS = objFileUrl.get(model.getId());
            if (CollectionUtils.isEmpty(multiFileDTOS)){
                continue;
            }
            if ("0".equals(model.getAnonymous())){
                model.setNikeName("匿名用户");
            }
            multiFileDTOS.forEach(s->{s.setFileurlfull(path+s.getFileurlfull());});
            model.setFileList(multiFileDTOS);
        }
        return PageData.from(result);
    }
}