package com.doumee.service.business.impl;

import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
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.BannerMapper;
import com.doumee.dao.business.LabelsMapper;
import com.doumee.dao.business.join.BannerJoinMapper;
import com.doumee.dao.business.model.Areas;
import com.doumee.dao.business.model.Banner;
import com.doumee.dao.business.model.Goods;
import com.doumee.dao.business.model.Labels;
import com.doumee.dao.web.dto.ArticleDTO;
import com.doumee.dao.web.dto.BannerDTO;
import com.doumee.dao.web.dto.LabelsBannerDTO;
import com.doumee.dao.web.dto.shop.ShopSimpleDTO;
import com.doumee.service.business.AreasService;
import com.doumee.service.business.BannerService;
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.LabelsService;
import com.doumee.service.business.ShopService;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

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

/**
 * 轮播图信息表Service实现
 * @author 江蹄蹄
 * @date 2023/03/21 15:48
 */
@Service
public class BannerServiceImpl implements BannerService {

    @Autowired
    private BannerMapper bannerMapper;

    @Autowired
    private SystemDictDataBiz systemDictDataBiz;

    @Autowired
    private ShopService shopService;

    @Autowired
    private BannerJoinMapper bannerJoinMapper;

    @Autowired
    AreasService areasService;

    @Autowired
    LabelsMapper labelsMapper;

    @Override
    public Integer create(Banner banner) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
    /*    if(banner.getPosition()==null
        ){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), ResponseStatus.BAD_REQUEST.getMessage());
        }*/
        banner.setIsdeleted(Constants.ZERO);
        banner.setCreateDate(new Date());
        banner.setCreator(user.getId());
        banner.setStatus(Constants.ZERO);
        bannerMapper.insert(banner);
        return banner.getId();
    }

    @Override
    public void deleteById(Integer id) {
        Banner banner=new Banner();
        banner.setIsdeleted(Constants.ONE);
        banner.setId(id);
        bannerMapper.updateById(banner);
    }

    @Override
    public void delete(Banner banner) {
        UpdateWrapper<Banner> deleteWrapper = new UpdateWrapper<>(banner);
        bannerMapper.delete(deleteWrapper);
    }

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

    @Override
    public void updateById(Banner banner) {
        LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
        banner.setEditDate(new Date());
        banner.setEditor(user.getId());
        bannerMapper.updateById(banner);
    }

    @Override
    public void updateByIdInBatch(List<Banner> banners) {
        if (CollectionUtils.isEmpty(banners)) {
            return;
        }
        for (Banner banner: banners) {
            this.updateById(banner);
        }
    }

    @Override
    public Banner findById(Integer id) {
        String path = systemDictDataBiz.queryByCode(Constants.OSS, Constants.RESOURCE_PATH).getCode() + systemDictDataBiz.queryByCode(Constants.OSS, Constants.BANNER_FILE).getCode();
        Banner result=bannerMapper.selectById(id);
        if(Objects.nonNull(result)&&StringUtils.isNotBlank(result.getImgurl())){
         result.setImgFullUrl(path+result.getImgurl());
        }
        return result;
    }

    @Override
    public Banner findOne(Banner banner) {
        QueryWrapper<Banner> wrapper = new QueryWrapper<>(banner);
        return bannerMapper.selectOne(wrapper);
    }

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

        queryWrapper.selectAll(Banner.class);
        queryWrapper.selectAs(Labels::getName,Banner::getParentName);
        queryWrapper.selectAs(Goods::getName,Banner::getGoodsName);
       // queryWrapper.selectAs(Areas::getParentId,Banner::getProvinceId);
       // queryWrapper.selectAs(Areas::getName,Banner::getCityName);
       /* queryWrapper.select("(select name from areas where id=t1.PARENT_ID) as provinceName");

        queryWrapper.select("(select name from shop where id=t.CONTENT and t.TYPE=3) as shopName");
        queryWrapper.select("(select name from activity where id=t.CONTENT and t.TYPE=2) as activityName");



        queryWrapper.eq(pageWrap.getModel().getPosition()!=null,Banner::getPosition,pageWrap.getModel().getPosition());*/
        queryWrapper.leftJoin(Goods.class,Goods::getId,Banner::getContent);
        queryWrapper.leftJoin(Labels.class,Labels::getId,Banner::getLabelId);
        queryWrapper.eq(Banner::getIsdeleted,Constants.ZERO);
        queryWrapper.orderByAsc(Banner::getSortnum);
        queryWrapper.orderByDesc(Banner::getCreateDate);

        IPage<Banner> result = bannerJoinMapper.selectJoinPage(page, Banner.class, queryWrapper);
        if(org.apache.commons.collections.CollectionUtils.isNotEmpty(result.getRecords())){
            String path = systemDictDataBiz.queryByCode(Constants.OSS, Constants.RESOURCE_PATH).getCode() + systemDictDataBiz.queryByCode(Constants.OSS, Constants.BANNER_FILE).getCode();

            result.getRecords().stream().forEach(s->{
                if(StringUtils.isNotBlank(s.getImgurl())){
                    s.setImgFullUrl(path+s.getImgurl());
                }
            });
        }
        return PageData.from(result);
    }

    @Override
    public long count(Banner banner) {
        QueryWrapper<Banner> wrapper = new QueryWrapper<>(banner);
        return bannerMapper.selectCount(wrapper);
    }

    @Override
    public List<BannerDTO> findShopBanner() {
        Banner banner = new Banner();
        banner.setPosition(Constants.TWO);
        QueryWrapper<Banner> wrapper = new QueryWrapper<>(banner);
        wrapper.lambda().orderByDesc(Banner::getSortnum);
        List<Banner> banners = bannerMapper.selectList(wrapper);
        List<BannerDTO> collect = banners.stream().map(s -> {
            BannerDTO dto = new BannerDTO();
            BeanUtils.copyProperties(s, dto);
            if (Constants.equalsInteger(dto.getType(),Constants.ZERO)){
                dto.setContent(null);
            }
            return dto;
        }).collect(Collectors.toList());
        return collect;
    }

    @Override
    public List<LabelsBannerDTO> findHomeBanner(Integer cityId) {

        QueryWrapper<Labels> labelsWrapper = new QueryWrapper<>();
        labelsWrapper.lambda()
                .eq(Labels::getIsdeleted,Constants.ZERO)
                .eq(Labels::getType,Constants.LabelsType.HOMEZHUANQU.getKey())
                .orderByAsc(Labels::getSortnum);
        List<Labels> labels = labelsMapper.selectList(labelsWrapper);

        if (CollectionUtils.isEmpty(labels)){
            return new ArrayList<>();
        }
        List<Integer> collect = labels.stream().map(s -> s.getId()).collect(Collectors.toList());
        String preFixPath = systemDictDataBiz.getPreFixPath(Constants.RESOURCE_PATH, Constants.BANNER_FILE);
        QueryWrapper<Banner> wrapper = new QueryWrapper<>();
        wrapper.lambda()
                .eq(Banner::getIsdeleted,Constants.ZERO)
                .in(Banner::getLabelId,collect)
                .orderByAsc(Banner::getSortnum);
        List<Banner> banners = bannerMapper.selectList(wrapper);

        Map<Integer, List<Banner>> bannerMap = banners.stream().collect(Collectors.groupingBy(s -> s.getLabelId()));

        List<LabelsBannerDTO> collect3 = labels.stream().map(s -> {
            LabelsBannerDTO dto = new LabelsBannerDTO();
            BeanUtils.copyProperties(s, dto);
            List<Banner> labelBanner = bannerMap.get(s.getId());
            if (!CollectionUtils.isEmpty(labelBanner)){
                List<BannerDTO> bannerDTOS = labelBanner.stream().map(b -> {
                    BannerDTO bannerDTO = new BannerDTO();
                    BeanUtils.copyProperties(b, bannerDTO);
                    bannerDTO.setImgurl(preFixPath + b.getImgurl());
                    return bannerDTO;
                }).collect(Collectors.toList());
                dto.setBannerDTOs(bannerDTOS);
            }
            return dto;
        }).collect(Collectors.toList());
        return collect3;
    }


    @Override
    public ArticleDTO findArticleBanner(Integer id) {
        Banner banner = bannerJoinMapper.selectById(id);
        ArticleDTO dto = new ArticleDTO();
        dto.setTitle(banner.getTitle());
        dto.setContent(banner.getContent());
        dto.setCreateDate(banner.getCreateDate());
        return dto;
    }

    @Override
    public List<BannerDTO> findRecommendShop(Integer cityId, String cityName) {

        if (Objects.isNull(cityId) && StringUtils.isBlank(cityName)){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"城市参数不能为空");
        }
        if (StringUtils.isNotBlank(cityName)){
            Areas byName = areasService.findByName(cityName, Constants.ONE);
            cityId = Objects.nonNull(cityId) ? cityId : byName.getId();
        }
        String preFixPath = systemDictDataBiz.getPreFixPath(Constants.RESOURCE_PATH, Constants.BANNER_FILE);
        QueryWrapper<Banner> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(Banner::getPosition,Constants.ONE)
                .eq(Banner::getCityId,cityId)
                .orderByDesc(Banner::getSortnum)
                .last("limit 3");
        List<Banner> banners = bannerMapper.selectList(wrapper);
        List<BannerDTO> collect = null;
        if (!CollectionUtils.isEmpty(banners)){
            collect = banners.stream().map(s -> {
                BannerDTO dto = new BannerDTO();
                dto.setImgurl(preFixPath+s.getImgurl());
                dto.setObjName(s.getObjName());
                dto.setContent(s.getContent());
                return dto;
            }).collect(Collectors.toList());
        }
        return collect;
    }


    @Override
    public PageData<ShopSimpleDTO> findRecommendShopPage(PageWrap<Banner> pageWrap) {
        IPage<Banner> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<Banner> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        queryWrapper.lambda().eq(Banner::getPosition, Constants.ONE);
        IPage<Banner> bannerIPage = bannerMapper.selectPage(page, queryWrapper);

        List<Integer> shopIds = bannerIPage.getRecords().stream().map(s -> Integer.valueOf(s.getContent())).collect(Collectors.toList());
        List<ShopSimpleDTO> shopSimpleDTOList = shopService.getShopSimpleDTOList(shopIds);

        IPage<ShopSimpleDTO> shopSimplePage = new Page<>();
        shopSimplePage.setRecords(shopSimpleDTOList);
        shopSimplePage.setPages(bannerIPage.getPages());
        shopSimplePage.setTotal(bannerIPage.getTotal());
        shopSimplePage.setSize(bannerIPage.getSize());
        shopSimplePage.setCurrent(bannerIPage.getCurrent());
        return PageData.from(shopSimplePage);
    }
}