package com.zksy.base.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zksy.base.domain.*;
import com.zksy.base.domain.vo.ProductCenterVo;
import com.zksy.base.mapper.*;
import com.zksy.base.service.BasicInfoService;
import com.zksy.base.service.MessageDataService;
import com.zksy.base.service.QualificationCertificateService;
import com.zksy.base.service.WebSiteService;
import org.apache.poi.util.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class WebSiteServiceImpl implements WebSiteService {
    @Autowired
    private SmartEmploymentMapper smartEmploymentMapper;
    @Autowired
    private AboutDevelopmentHistoryMapper aboutDevelopmentHistoryMapper;
    @Autowired
    private QualificationCertificateService qualificationCertificateService;
    @Autowired
    private BasicInfoService basicInfoService;
    @Autowired
    private NewsUpdatesMapper newsUpdatesMapper;
    @Autowired
    private SolutionMapper solutionMapper;
    @Autowired
    private ProductCenterMapper productCenterMapper;
    @Autowired
    private LocationInforMapper locationInforMapper;
    @Autowired
    private MessageDataService messageDataService;

    @Override
    public Page<SmartEmployment> getRecruitmentInfoByPage(Integer pageNum, Integer pageSize) {
        Page<SmartEmployment> page = new Page<>(pageNum, pageSize);
        return smartEmploymentMapper.selectPage(page, Wrappers.emptyWrapper());
    }

    @Override
    public SmartEmployment getRecruitmentInfoById(String id) {
        return smartEmploymentMapper.selectById(id);
    }

    @Override
    public List<AboutDevelopmentHistory> getDevelopmentHistory() {
        LambdaQueryWrapper<AboutDevelopmentHistory> wrapper = new LambdaQueryWrapper<>();
        wrapper.orderByAsc(AboutDevelopmentHistory::getYear);
        return aboutDevelopmentHistoryMapper.selectList(wrapper);
    }

    @Override
    public List<QualificationCertificate> getHoner() {
        return qualificationCertificateService.listQualificationCertificate();
    }

    @Override
    public List<BasicInfo> getBasicInfo() {
        return basicInfoService.list();
    }

    @Override
    public Page<NewsUpdates> getNewsUpdatesListWithoutSpecialNews(Integer pageNum, Integer pageSize, String newsCategory) {
        if(StringUtils.isNotBlank(newsCategory)){
            return newsUpdatesMapper.selectPage(new Page<>(pageNum, pageSize), Wrappers.lambdaQuery(NewsUpdates.class).eq(NewsUpdates::getNewsCategory, newsCategory).eq(NewsUpdates::getIsSpecial, false).orderByDesc(NewsUpdates::getCreateTime));
        }
        return newsUpdatesMapper.selectPage(new Page<>(pageNum, pageSize), Wrappers.lambdaQuery(NewsUpdates.class).eq(NewsUpdates::getIsSpecial, false).orderByDesc(NewsUpdates::getCreateTime));
    }

    @Override
    public Page<NewsUpdates> getSpecialNewsUpdatesList(Integer pageNum, Integer pageSize) {
        return newsUpdatesMapper.selectPage(new Page<>(pageNum, pageSize), Wrappers.lambdaQuery(NewsUpdates.class).eq(NewsUpdates::getIsSpecial, true).orderByDesc(NewsUpdates::getCreateTime));
    }

    @Override
    public NewsUpdates getNewsUpdatesById(String id) {
        return newsUpdatesMapper.selectById(id);
    }

    @Override
    public Solution getSolutionById(String id) {
        return solutionMapper.selectById(id);
    }

    @Override
    public Page<Solution> getSolution(Integer pageNum, Integer pageSize) {
        Page<Solution> page = new Page<>(pageNum, pageSize);
        LambdaQueryWrapper<Solution> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.orderByDesc(Solution::getReleaseTime);
        return solutionMapper.selectPage(page, queryWrapper);
    }

    @Override
    public List<ProductCenterVo> getProductCategoryAndType() {
        return productCenterMapper.selectList(Wrappers.emptyWrapper())
                .stream()
                .collect(
                        Collectors.groupingBy(ProductCenter::getProductCategory)
                )
                .entrySet()
                .stream()
                .map(entry -> new ProductCenterVo(
                                entry.getKey(),
                                entry.getValue().stream().collect(
                                        Collectors.groupingBy(ProductCenter::getProductType)
                                ).entrySet().stream().map(
                                        typeEntry -> new ProductCenterVo.ProductType(
                                                typeEntry.getKey(),
                                                typeEntry.getValue().stream().map(
                                                        productCenter -> new ProductCenterVo.ProductItem(
                                                                productCenter.getId(),
                                                                productCenter.getProductCategory(),
                                                                productCenter.getProductType(),
                                                                productCenter.getProductName(),
                                                                productCenter.getProductModel(),
                                                                productCenter.getProductIntroduction(),
                                                                productCenter.getProductScene(),
                                                                productCenter.getProductUrl(),
                                                                productCenter.getIsCore()
                                                        )
                                                ).collect(Collectors.toList())
                                        )
                                ).collect(Collectors.toList())
                        )
                ).collect(Collectors.toList());
    }

    @Override
    public ProductCenter getProductById(String id) {
        return productCenterMapper.selectById(id);
    }

    @Override
    public Page<ProductCenter> getProductByPage(Integer pageNum, Integer pageSize) {
        Page<ProductCenter> page = new Page<>(pageNum, pageSize);
        LambdaQueryWrapper<ProductCenter> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.orderByDesc(ProductCenter::getCreateTime);
        return productCenterMapper.selectPage(page, queryWrapper);
    }

    @Override
    public List<LocationInfor> getLocationInforList() {
        LambdaQueryWrapper<LocationInfor> wrapper = new LambdaQueryWrapper<>();
        wrapper.orderByAsc(LocationInfor::getCreateTime);
        return locationInforMapper.selectList(wrapper);
    }

    @Override
    public Boolean saveMessage(MessageData messageData) {
        messageData.setCreateTime(LocalDateTime.now());
        messageData.setUpdateTime(LocalDateTime.now());
        return messageDataService.save(messageData);
    }

}