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

import cc.mrbird.febs.common.entity.FebsResponse;
import cc.mrbird.febs.common.enumerates.*;
import cc.mrbird.febs.common.exception.FebsException;
import cc.mrbird.febs.common.utils.LoginUserUtil;
import cc.mrbird.febs.mall.dto.clothes.*;
import cc.mrbird.febs.mall.entity.*;
import cc.mrbird.febs.mall.mapper.*;
import cc.mrbird.febs.mall.service.ApiClothesSocialService;
import cc.mrbird.febs.mall.vo.activity.ApiScCategoryInfoVo;
import cc.mrbird.febs.mall.vo.clothes.*;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSON;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import io.swagger.annotations.ApiModelProperty;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@Service
@RequiredArgsConstructor
public class ApiClothesSocialServiceImpl extends ServiceImpl<ClothesSocialMapper, ClothesSocial> implements ApiClothesSocialService {

    private final ClothesSocialMapper clothesSocialMapper;
    private final ClothesSocialFileMapper clothesSocialFileMapper;
    private final ClothesSocialMuseMapper clothesSocialMuseMapper;
    private final ClothesSocialCategoryMapper clothesSocialCategoryMapper;
    private final MallMemberMapper mallMemberMapper;


    private final ClothesTypeMapper clothesTypeMapper;
    private final ClothesSizeMapper clothesSizeMapper;
    private final ClothesPatternMapper clothesPatternMapper;
    private final ClothesLocationMapper clothesLocationMapper;
    private final ClothesClothMapper clothesClothMapper;
    private final ClothesArtMapper clothesArtMapper;
    private final ClothesOrderMapper clothesOrderMapper;
    private final ClothesOrderItemMapper clothesOrderItemMapper;
    private final ClothesSocialFollowMapper clothesSocialFollowMapper;


    private final ClothesTypeClothMapper clothesTypeClothMapper;
    private final ClothesTypePatternMapper clothesTypePatternMapper;
    private final ClothesTypeSizeMapper clothesTypeSizeMapper;
    private final ClothesTypeLocationMapper clothesTypeLocationMapper;
    private final ClothesTypeArtMapper clothesTypeArtMapper;
    private final ClothesLocationRemarkMapper clothesLocationRemarkMapper;
    private final ClothesPatternRemarkMapper clothesPatternRemarkMapper;
    private final ClothesSocialCommentMapper clothesSocialCommentMapper;


    @Override
    public FebsResponse allCategory() {
        List<ApiClothesCategoryInfoVo> vos = new ArrayList<>();
        List<ClothesSocialCategory> list = clothesSocialCategoryMapper.selectList(
                Wrappers.lambdaQuery(ClothesSocialCategory.class)
                        .select(ClothesSocialCategory::getId, ClothesSocialCategory::getName)
                        .eq(ClothesSocialCategory::getState, ClothesEnum.UP.getCode())
                        .eq(ClothesSocialCategory::getDeleteFlag, ClothesEnum.DOWN.getCode())
                        .orderByAsc(ClothesSocialCategory::getOrderCnt)
        );
        if(CollUtil.isNotEmpty(list)){
            vos = buildApiClothesCategoryInfoVo(list, vos);
        }
        return new FebsResponse().success().data(vos);
    }

    private List<ApiClothesCategoryInfoVo> buildApiClothesCategoryInfoVo(List<ClothesSocialCategory> list, List<ApiClothesCategoryInfoVo> vos) {
        for (ClothesSocialCategory entity : list) {
            ApiClothesCategoryInfoVo vo = new ApiClothesCategoryInfoVo();
            vo.setId(entity.getId());
            vo.setName(entity.getName());
            vos.add(vo);
        }
        return vos;
    }

    @Override
    public FebsResponse indexCategory() {
        List<ApiClothesCategoryInfoVo> vos = new ArrayList<>();
        List<ClothesSocialCategory> list = clothesSocialCategoryMapper.selectList(
                Wrappers.lambdaQuery(ClothesSocialCategory.class)
                        .select(ClothesSocialCategory::getId, ClothesSocialCategory::getName)
                        .eq(ClothesSocialCategory::getState, ClothesEnum.UP.getCode())
                        .eq(ClothesSocialCategory::getHotState, ClothesEnum.UP.getCode())
                        .eq(ClothesSocialCategory::getDeleteFlag, ClothesEnum.DOWN.getCode())
                        .orderByAsc(ClothesSocialCategory::getOrderCnt)
        );
        if(CollUtil.isNotEmpty(list)){
            vos = buildApiClothesCategoryInfoVo(list, vos);
        }
        return new FebsResponse().success().data(vos);
    }

    @Override
    public FebsResponse allSocial(ApiAllSocialDto dto) {
        // 创建分页对象，传入当前页和每页大小
        Page<ApiAllSocialVo> page = new Page<>(dto.getPageNow(), dto.getPageSize());
        // 调用Mapper方法获取活动分页数据
        Page<ApiAllSocialVo> voPage = clothesSocialMapper.selectPageInSocial(page, dto);

        List<ApiAllSocialVo> vos = voPage.getRecords();
        if (CollUtil.isNotEmpty(vos)) {
            Set<Long> socialIds = vos.stream()
                    .map(ApiAllSocialVo::getId)
                    .filter(Objects::nonNull)
                    .collect(Collectors.toSet());

            if (CollUtil.isNotEmpty(socialIds)) {
                List<ClothesSocialFollow> clothesSocialFollows = clothesSocialFollowMapper.selectList(
                        Wrappers.lambdaQuery(ClothesSocialFollow.class)
                                .select(ClothesSocialFollow::getId, ClothesSocialFollow::getSourceId)
                                .in(ClothesSocialFollow::getSourceId, socialIds)
                                .eq(ClothesSocialFollow::getType, SocialTypeEnum.LIKE.getValue())
                );

                Map<Long, Long> likeCountBySocialIdMap = new HashMap<>();
                if (CollUtil.isNotEmpty(clothesSocialFollows)) {
                    likeCountBySocialIdMap = clothesSocialFollows.stream()
                            .collect(Collectors.groupingBy(ClothesSocialFollow::getSourceId, Collectors.counting()));
                }

                for (ApiAllSocialVo item : vos){
                    item.setLikeCnt(likeCountBySocialIdMap.getOrDefault(item.getId(), 0L).intValue());
                }
            }
        }

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


    @Override
    public FebsResponse socialInfo(ApiSocialInfoDto dto) {
        ApiSocialInfoVo apiSocialInfoVo = new ApiSocialInfoVo();
        Long socialId = dto.getSocialId();
        ClothesSocial clothesSocial = clothesSocialMapper.selectById(socialId);
        if(ObjectUtil.isNotNull(clothesSocial)){
            MallMember mallMember = mallMemberMapper.selectById(clothesSocial.getMemberId());
            apiSocialInfoVo.setId(clothesSocial.getId());
            apiSocialInfoVo.setMemberName(mallMember.getName());
            apiSocialInfoVo.setMemberAvatar(mallMember.getAvatar());
            apiSocialInfoVo.setName(clothesSocial.getName());
            apiSocialInfoVo.setContent(clothesSocial.getContent());
            apiSocialInfoVo.setCreatedTime(clothesSocial.getCreatedTime());
            apiSocialInfoVo.setCommentState(clothesSocial.getCommentState());

            List<ClothesSocialFile> clothesSocialFiles = clothesSocialFileMapper.selectList(
                    Wrappers.lambdaQuery(ClothesSocialFile.class)
                            .select(ClothesSocialFile::getFileUrl)
                            .eq(ClothesSocialFile::getSocialId, socialId)
                            .orderByAsc(ClothesSocialFile::getSeq)
            );
            if(CollUtil.isNotEmpty(clothesSocialFiles)){
                apiSocialInfoVo.setImages(clothesSocialFiles.stream().map(ClothesSocialFile::getFileUrl).collect(Collectors.toList()));
            }

            ApiSocialMuseVo apiSocialMuseVo = new ApiSocialMuseVo();
            ClothesSocialMuse clothesSocialMuse = clothesSocialMuseMapper.selectOne(
                    Wrappers.lambdaQuery(ClothesSocialMuse.class)
                            .eq(ClothesSocialMuse::getSocialId, socialId)
                            .last("LIMIT 1")
            );
            if(ObjectUtil.isNotNull(clothesSocialMuse)){
                BigDecimal totalAmount = BigDecimal.ZERO;
                apiSocialMuseVo.setMuseId(clothesSocialMuse.getId());
                ClothesType clothesType = clothesTypeMapper.selectById(clothesSocialMuse.getTypeId());
                if(ObjectUtil.isNotNull(clothesType)){
                    apiSocialMuseVo.setTypeName(clothesType.getName());
                    apiSocialMuseVo.setTypeImg(clothesType.getImage());
                }
                ClothesSize clothesSize = clothesSizeMapper.selectById(clothesSocialMuse.getSizeId());
                if(ObjectUtil.isNotNull(clothesSize)){
                    apiSocialMuseVo.setSizeName(clothesSize.getName());
                    totalAmount = totalAmount.add(clothesSize.getPrice());
                }
                ClothesCloth clothesCloth = clothesClothMapper.selectById(clothesSocialMuse.getClothId());
                if(ObjectUtil.isNotNull(clothesCloth)){
                    apiSocialMuseVo.setClothName(clothesCloth.getName());
                    totalAmount = totalAmount.add(clothesCloth.getPrice());
                }
                ClothesArt clothesArt = clothesArtMapper.selectById(clothesSocialMuse.getArtId());
                if(ObjectUtil.isNotNull(clothesArt)){
                    apiSocialMuseVo.setArtName(clothesArt.getName());
                    totalAmount = totalAmount.add(clothesArt.getPrice());
                }


                List<ApiClothesPatternRemarkVo> patternRemarkList = new ArrayList<>();

                List<ClothesPatternRemark> patternRemarks = clothesPatternRemarkMapper.selectList(
                        Wrappers.lambdaQuery(ClothesPatternRemark.class)
                                .eq(ClothesPatternRemark::getSourceId, clothesSocialMuse.getId())
                                .eq(ClothesPatternRemark::getType, SocialPatternLocationTypeEnum.MUSE.getValue())
                );
                if(CollUtil.isNotEmpty(patternRemarks)){
                    for (ClothesPatternRemark entity : patternRemarks){
                        ApiClothesPatternRemarkVo vo = new ApiClothesPatternRemarkVo();
                        ClothesPattern pattern = clothesPatternMapper.selectById(entity.getPatternId());
                        vo.setPatternName(pattern.getName());
                        vo.setPatternRemark(entity.getRemark());
                        patternRemarkList.add( vo);

                        totalAmount = totalAmount.add(pattern.getPrice());
                    }
                    apiSocialMuseVo.setPatternRemarkList(patternRemarkList);
                }

                List<ApiClothesLocationRemarkVo> locationRemarkList = new ArrayList<>();
                List<ClothesLocationRemark> locationRemarks = clothesLocationRemarkMapper.selectList(
                        Wrappers.lambdaQuery(ClothesLocationRemark.class)
                                .eq(ClothesLocationRemark::getSourceId, clothesSocialMuse.getId())
                                .eq(ClothesLocationRemark::getType, SocialPatternLocationTypeEnum.MUSE.getValue())
                );
                if(CollUtil.isNotEmpty(locationRemarks)){
                    for (ClothesLocationRemark entity : locationRemarks){
                        ApiClothesLocationRemarkVo vo = new ApiClothesLocationRemarkVo();
                        ClothesLocation clothesLocation = clothesLocationMapper.selectById(entity.getLocationId());
                        vo.setLocationName(clothesLocation.getName());
                        vo.setLocationRemark(entity.getRemark());
                        locationRemarkList.add(vo);

                        totalAmount = totalAmount.add(clothesLocation.getPrice());
                    }
                    apiSocialMuseVo.setLocationRemarkList(locationRemarkList);
                }
                apiSocialMuseVo.setTotalAmount(totalAmount.setScale(2, RoundingMode.DOWN));

                List<ClothesSocialFollow> clothesSocialFollows = clothesSocialFollowMapper.selectList(
                        Wrappers.lambdaQuery(ClothesSocialFollow.class)
                                .select(ClothesSocialFollow::getType)
                                .eq(ClothesSocialFollow::getSourceId, socialId)
                );
                if (CollUtil.isNotEmpty(clothesSocialFollows)){

                    Map<Integer, Long> collect = clothesSocialFollows.stream()
                            .collect(Collectors.groupingBy(ClothesSocialFollow::getType, Collectors.counting()));
                    apiSocialInfoVo.setLikeCnt(collect.getOrDefault(SocialTypeEnum.LIKE.getValue(), 0L).intValue());
                    apiSocialInfoVo.setCollectCnt(collect.getOrDefault(SocialTypeEnum.COLLECT.getValue(), 0L).intValue());
                }

                List<ClothesSocialComment> clothesSocialComments = clothesSocialCommentMapper.selectList(
                        Wrappers.lambdaQuery(ClothesSocialComment.class)
                                .eq(ClothesSocialComment::getSocialId, socialId)
                                .eq(ClothesSocialComment::getShowState, ClothesEnum.UP.getCode())
                                .isNull(ClothesSocialComment::getParentId)
                );
                if (CollUtil.isNotEmpty(clothesSocialComments)){
                    apiSocialInfoVo.setCommentCnt(clothesSocialComments.size());
                }
            }
        }


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

    @Override
    @Transactional
    public FebsResponse socialAdd(ApiSocialAddDto dto) {

        Long memberId = LoginUserUtil.getLoginUser().getId();
        Long orderId = dto.getOrderId();
        ClothesOrder order = clothesOrderMapper.selectOne(
                Wrappers.lambdaQuery(ClothesOrder.class)
                        .eq(ClothesOrder::getId, orderId)
                        .eq(ClothesOrder::getMemberId, memberId)
        );
        if(ObjectUtil.isNull( order)){
            throw new FebsException("请选择订单");
        }
        if(ClothesOrderStatusEnum.FINISH.getValue() != order.getStatus()){
            throw new FebsException("订单未确认收货");
        }

        String content = dto.getContent();
        List<String> contentFile = dto.getContentFile();
        String indexFile = dto.getIndexFile();
        String title = dto.getTitle();

        ClothesSocial clothesSocial = new ClothesSocial();
        clothesSocial.setMemberId(memberId);
        clothesSocial.setName(title);
        clothesSocial.setContent(content);
        clothesSocial.setIndexFile(indexFile);
        clothesSocialMapper.insert(clothesSocial);

        if(CollUtil.isNotEmpty(contentFile)){
            int i = 0;
            for (String file : contentFile){
                ClothesSocialFile clothesSocialFile = new ClothesSocialFile();
                clothesSocialFile.setSocialId(clothesSocial.getId());
                clothesSocialFile.setFileUrl(file);
                clothesSocialFile.setSeq(i);
                clothesSocialFileMapper.insert(clothesSocialFile);
                i++;
            }
        }

        ClothesSocialMuse clothesSocialMuse = new ClothesSocialMuse();
        clothesSocialMuse.setSocialId(clothesSocial.getId());
        clothesSocialMuse.setTypeId(order.getTypeId());

        List<ClothesOrderItem> clothesOrderItems = clothesOrderItemMapper.selectList(
                Wrappers.lambdaQuery(ClothesOrderItem.class)
                        .eq(ClothesOrderItem::getOrderId, orderId)
        );

        List<ClothesLocationRemark> clothesLocationRemarks = new ArrayList<>();
        List<ClothesPatternRemark> clothesPatternRemarks = new ArrayList<>();
        if(CollUtil.isEmpty(clothesOrderItems)){
            for (ClothesOrderItem item : clothesOrderItems){
                if (ClothesOrderItemEnum.CLOTH.getCode() == item.getType()) {
                    ClothesCloth cloth = clothesClothMapper.selectById(item.getItemId());
                    clothesSocialMuse.setClothId(cloth.getId());
                    continue;
                } else if (ClothesOrderItemEnum.SIZE.getCode() == item.getType()) {
                    ClothesSize size = clothesSizeMapper.selectById(item.getItemId());
                    clothesSocialMuse.setSizeId(size.getId());
                    continue;
                } else if (ClothesOrderItemEnum.LOCATION.getCode() == item.getType()) {
                    ClothesLocation location = clothesLocationMapper.selectById(item.getItemId());
                    ClothesLocationRemark entity = new ClothesLocationRemark();
                    entity.setLocationId(location.getId());
                    entity.setMemberId(memberId);
                    entity.setSourceId(clothesSocialMuse.getId());
                    entity.setType(SocialPatternLocationTypeEnum.MUSE.getValue());
                    entity.setRemark(item.getRemark());
                    clothesLocationRemarks.add(entity);
                    continue;
                } else if (ClothesOrderItemEnum.PATTERN.getCode() == item.getType()) {
                    ClothesPattern pattern = clothesPatternMapper.selectById(item.getItemId());
                    ClothesPatternRemark entity = new ClothesPatternRemark();
                    entity.setPatternId(pattern.getId());
                    entity.setMemberId(memberId);
                    entity.setSourceId(clothesSocialMuse.getId());
                    entity.setType(SocialPatternLocationTypeEnum.MUSE.getValue());
                    entity.setRemark(item.getRemark());
                    clothesPatternRemarks.add(entity);
                    continue;
                } else if (ClothesOrderItemEnum.ART.getCode() == item.getType()) {
                    ClothesArt art = clothesArtMapper.selectById(item.getItemId());
                    clothesSocialMuse.setArtId(art.getId());
                    continue;
                }else{
                    continue;
                }
            }
        }
        clothesSocialMuseMapper.insert(clothesSocialMuse);

        if (CollUtil.isNotEmpty(clothesLocationRemarks)){
            for (ClothesLocationRemark entity : clothesLocationRemarks){
                entity.setSourceId(clothesSocialMuse.getId());
                clothesLocationRemarkMapper.insert(entity);
            }
        }

        if (CollUtil.isNotEmpty(clothesPatternRemarks)){
            for (ClothesPatternRemark entity : clothesPatternRemarks){
                entity.setSourceId(clothesSocialMuse.getId());
                clothesPatternRemarkMapper.insert(entity);
            }
        }
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse addLike(ApiSocialLikeAddDto dto) {

        Long memberId = LoginUserUtil.getLoginUser().getId();
        Long socialId = dto.getSocialId();
        ClothesSocial clothesSocial = clothesSocialMapper.selectById(socialId);
        if(ObjectUtil.isNotNull(clothesSocial)){
            ClothesSocialFollow clothesSocialFollow = new ClothesSocialFollow();
            clothesSocialFollow.setMemberId(memberId);
            clothesSocialFollow.setSourceType(SocialSourceTypeEnum.SOCIAL.getValue());
            clothesSocialFollow.setSourceId(socialId);
            clothesSocialFollow.setType(SocialTypeEnum.LIKE.getValue());
            clothesSocialFollowMapper.insert(clothesSocialFollow);
        }
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse addCommentLike(ApiSocialCommentLikeAddDto dto) {
        Long memberId = LoginUserUtil.getLoginUser().getId();
        Long socialId = dto.getSocialId();
        ClothesSocial clothesSocial = clothesSocialMapper.selectById(socialId);
        if(ObjectUtil.isNotNull(clothesSocial)){
            ClothesSocialFollow clothesSocialFollow = new ClothesSocialFollow();
            clothesSocialFollow.setMemberId(memberId);
            clothesSocialFollow.setSourceType(SocialSourceTypeEnum.COMMENT.getValue());
            clothesSocialFollow.setSourceId(socialId);
            clothesSocialFollow.setSourceOptionId(dto.getCommentId());
            clothesSocialFollow.setType(SocialTypeEnum.LIKE.getValue());
            clothesSocialFollowMapper.insert(clothesSocialFollow);
        }
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse addCollect(ApiSocialCollectAddDto dto) {

        Long memberId = LoginUserUtil.getLoginUser().getId();
        Long socialId = dto.getSocialId();
        ClothesSocial clothesSocial = clothesSocialMapper.selectById(socialId);
        if(ObjectUtil.isNotNull(clothesSocial)){
            ClothesSocialFollow clothesSocialFollow = new ClothesSocialFollow();
            clothesSocialFollow.setMemberId(memberId);
            clothesSocialFollow.setSourceType(SocialSourceTypeEnum.SOCIAL.getValue());
            clothesSocialFollow.setSourceId(socialId);
            clothesSocialFollow.setType(SocialTypeEnum.COLLECT.getValue());
            clothesSocialFollowMapper.insert(clothesSocialFollow);
        }
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse museToDesign(ApiClothesSocialMuseDto dto) {

        Long memberId = LoginUserUtil.getLoginUser().getId();
        ApiClothesSocialMuseVo record = new ApiClothesSocialMuseVo();

        Long id = dto.getMuseId();
        ClothesSocialMuse entity = clothesSocialMuseMapper.selectById(id);


        if (ObjectUtil.isNotNull(entity)){
            Long typeId = entity.getTypeId();
            ClothesType clothesType = clothesTypeMapper.selectById(typeId);
            record.setTypeId(typeId);
            record.setTypeName(clothesType.getName());
            record.setTypeImage(clothesType.getImage());

            Long sizeId = ObjectUtil.defaultIfNull(entity.getSizeId(),0L);
            List<ClothesTypeSize> clothesTypeSizes = clothesTypeSizeMapper.selectList(Wrappers.<ClothesTypeSize>lambdaQuery().eq(ClothesTypeSize::getTypeId, typeId));
            if (CollUtil.isNotEmpty(clothesTypeSizes)){
                Set<Long> collect = clothesTypeSizes.stream().map(ClothesTypeSize::getSizeId).collect(Collectors.toSet());
                if(CollUtil.isNotEmpty( collect) && collect.contains(sizeId)){
                    ClothesSize clothesSize = clothesSizeMapper.selectById(sizeId);
                    if(ObjectUtil.isNotNull(clothesSize)){
                        record.setSizeId(sizeId);
                        record.setSizeName(clothesSize.getName());
                        record.setSizePrice(clothesSize.getPrice());
                    }
                }
            }

            BigDecimal totalPatternAmount = BigDecimal.ZERO;
            List<ApiClothesPatternRemarkVo> patternRemarkList = new ArrayList<>();
            List<ClothesPatternRemark> patternRemarks = clothesPatternRemarkMapper.selectList(
                    Wrappers.lambdaQuery(ClothesPatternRemark.class)
                            .eq(ClothesPatternRemark::getSourceId, entity.getId())
                            .eq(ClothesPatternRemark::getType, SocialPatternLocationTypeEnum.MUSE.getValue())
            );
            if(CollUtil.isNotEmpty(patternRemarks)){
                for (ClothesPatternRemark patternRemark : patternRemarks){
                    ApiClothesPatternRemarkVo vo = new ApiClothesPatternRemarkVo();
                    ClothesPattern pattern = clothesPatternMapper.selectById(patternRemark.getPatternId());
                    vo.setPatternName(pattern.getName());
                    vo.setPatternPrice(pattern.getPrice());
                    vo.setPatternId(pattern.getId());
                    vo.setPatternRemark(patternRemark.getRemark());
                    patternRemarkList.add( vo);

                    totalPatternAmount = totalPatternAmount.add(pattern.getPrice());
                }
                record.setPatternRemarkList(patternRemarkList);
            }


            BigDecimal totalLocationAmount = BigDecimal.ZERO;
            List<ApiClothesLocationRemarkVo> locationRemarkList = new ArrayList<>();
            List<ClothesLocationRemark> locationRemarks = clothesLocationRemarkMapper.selectList(
                    Wrappers.lambdaQuery(ClothesLocationRemark.class)
                            .eq(ClothesLocationRemark::getSourceId, entity.getId())
                            .eq(ClothesLocationRemark::getType, SocialPatternLocationTypeEnum.MUSE.getValue())
            );
            if(CollUtil.isNotEmpty(locationRemarks)){
                for (ClothesLocationRemark locationRemark : locationRemarks){
                    ApiClothesLocationRemarkVo vo = new ApiClothesLocationRemarkVo();
                    ClothesLocation clothesLocation = clothesLocationMapper.selectById(locationRemark.getLocationId());
                    vo.setLocationName(clothesLocation.getName());
                    vo.setLocationRemark(locationRemark.getRemark());
                    vo.setLocationPrice(clothesLocation.getPrice());
                    vo.setLocationId(clothesLocation.getId());
                    locationRemarkList.add(vo);

                    totalLocationAmount = totalLocationAmount.add(clothesLocation.getPrice());
                }
                record.setLocationRemarkList(locationRemarkList);
            }

            Long artId = ObjectUtil.defaultIfNull(entity.getArtId(),0L);
            List<ClothesTypeArt> clothesTypeArts = clothesTypeArtMapper.selectList(Wrappers.lambdaQuery(ClothesTypeArt.class).eq(ClothesTypeArt::getTypeId, typeId));
            if(CollUtil.isNotEmpty(clothesTypeArts)){
                Set<Long> artIds = clothesTypeArts.stream().map(ClothesTypeArt::getArtId).collect(Collectors.toSet());
                if (CollUtil.isNotEmpty(artIds) && artIds.contains(artId)){
                    ClothesArt clothesArt = clothesArtMapper.selectById(artId);
                    if (ObjectUtil.isNotNull(clothesArt)){
                        record.setArtId(artId);
                        record.setArtName(clothesArt.getName());
                        record.setArtPrice(clothesArt.getPrice());
                    }
                }
            }

            Long clothId = ObjectUtil.defaultIfNull(entity.getClothId(),0L);
            List<ClothesTypeCloth> clothesTypeCloths = clothesTypeClothMapper.selectList(Wrappers.lambdaQuery(ClothesTypeCloth.class).eq(ClothesTypeCloth::getTypeId, typeId));
            if(CollUtil.isNotEmpty(clothesTypeCloths)){
                Set<Long> clothIds = clothesTypeCloths.stream().map(ClothesTypeCloth::getClothId).collect(Collectors.toSet());
                if (CollUtil.isNotEmpty(clothIds) && clothIds.contains(clothId)){
                    ClothesCloth clothesCloth = clothesClothMapper.selectById(clothId);
                    if (ObjectUtil.isNotNull(clothesCloth)){
                        record.setClothId(clothId);
                        record.setClothName(clothesCloth.getName());
                        record.setClothPrice(clothesCloth.getPrice());
                    }
                }
            }

            BigDecimal amount =
                    record.getClothPrice()
                            .add(totalLocationAmount)
                            .add(record.getArtPrice())
                            .add(record.getSizePrice())
                            .add(totalPatternAmount)
                            .setScale(2, RoundingMode.DOWN);
            record.setAmount(amount);
        }

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

    @Override
    public FebsResponse comment(ApiClothesSocialCommentDto dto) {

        Long memberId = LoginUserUtil.getLoginUser().getId();
        Long socialId = dto.getSocialId();
        Long commentId = dto.getCommentId();
        ClothesSocial clothesSocial = clothesSocialMapper.selectById(socialId);
        if (ObjectUtil.isNull(clothesSocial)){
            return new FebsResponse().fail().message("社区不存在");
        }
        if (ClothesEnum.DOWN.getCode() == clothesSocial.getCommentState()){
            return new FebsResponse().fail().message("禁止评论");
        }
        ClothesSocialComment entity = new ClothesSocialComment();
        entity.setMemberId(memberId);
        entity.setSocialId(socialId);
        entity.setComment(dto.getComment());
        ClothesSocialComment clothesSocialComment = clothesSocialCommentMapper.selectById(commentId);
        if(ObjectUtil.isNotNull(clothesSocialComment)){
            entity.setParentId(clothesSocialComment.getParentId());
            entity.setCommentId(clothesSocialComment.getId());
        }
        clothesSocialCommentMapper.insert(entity);

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

    @Override
    public FebsResponse allComment(ApiAllCommentDto dto) {
        // 创建分页对象，传入当前页和每页大小
        Page<ApiAllCommentVo> page = new Page<>(dto.getPageNow(), dto.getPageSize());
        // 调用Mapper方法获取活动分页数据
        Page<ApiAllCommentVo> voPage = clothesSocialCommentMapper.selectPageInComment(page, dto);
        List<ApiAllCommentVo> records = voPage.getRecords();
        if (CollUtil.isNotEmpty(records)){
            Set<Long> collect = records.stream().map(ApiAllCommentVo::getCommentId).collect(Collectors.toSet());
            List<ClothesSocialComment> clothesSocialComments = clothesSocialCommentMapper.selectList(
                    Wrappers.lambdaQuery(ClothesSocialComment.class)
                            .select(ClothesSocialComment::getParentId)
                            .in(ClothesSocialComment::getParentId, collect)
                            .eq(ClothesSocialComment::getShowState, ClothesEnum.UP.getCode())
            );
            if (CollUtil.isNotEmpty(clothesSocialComments)){
                Map<Long, Long> collect1 = clothesSocialComments.stream()
                        .collect(Collectors.groupingBy(ClothesSocialComment::getParentId, Collectors.counting()));
                for (ApiAllCommentVo vo : records){
                    vo.setCommentCnt(collect1.getOrDefault(vo.getCommentId(), 0L).intValue());
                }
            }
        }
        return new FebsResponse().success().data(voPage);
    }

    public static void main(String[] args) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.putByPath("text", "123");
        jsonObject.putByPath("file", "https://excoin.oss-cn-hangzhou.aliyuncs.com/hc/175196952995698f416e2e70648328d04364340c3a36d.png");

        String jsonStr = jsonObject.toString();
        System.out.println(jsonStr);
    }
}