package com.cool.store.dao;

import cn.hutool.core.collection.CollStreamUtil;
import com.cool.store.dto.store.StoreAddressDTO;
import com.cool.store.dto.store.StoreOrderTimeDTO;
import com.cool.store.entity.StoreDO;
import com.cool.store.enums.StoreStatusEnum;
import com.cool.store.mapper.StoreMapper;
import com.cool.store.response.MiniShopsResponse;
import com.google.common.collect.Lists;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Repository
public class StoreDao {

    @Resource
    private StoreMapper storeMapper;
    /**
     * 根据门店id查询门店
     * @param storeId
     * @return
     */
    public StoreDO getByStoreId(String storeId) {
        if(StringUtils.isBlank(storeId)) {
            return null;
        }
        return storeMapper.getByStoreId(storeId);
    }

    public StoreDO getEffectiveByStoreId(String storeId) {
        if(StringUtils.isBlank(storeId)) {
            return null;
        }
        return storeMapper.getEffectiveByStoreId(storeId);
    }

    public List<StoreDO> getEffectiveStoreByStoreIds(List<String> storeIdList) {
        if(CollectionUtils.isEmpty(storeIdList)) {
            return Lists.newArrayList();
        }
        return storeMapper.getEffectiveStoreByStoreIds(storeIdList);
    }

    public List<StoreDO> listStoreByRegionId(String regionId) {
        if(StringUtils.isBlank(regionId)) {
            return Lists.newArrayList();
        }
        return storeMapper.listStoreByRegionId(regionId);
    }

    public List<String> getStoreNumByStoreIds(List<String> storeIdList) {
        if(CollectionUtils.isEmpty(storeIdList)) {
            return Lists.newArrayList();
        }
        return storeMapper.getStoreNumByStoreIds(storeIdList);
    }

    public StoreDO getByStoreNum(String storeNum) {
        if(StringUtils.isBlank(storeNum)) {
            return null;
        }
        return storeMapper.getByStoreNum(storeNum);
    }

    public List<StoreDO> listByMobile(String mobile) {
        if(StringUtils.isBlank(mobile)) {
            return new ArrayList<>();
        }
        return storeMapper.listByMobile(mobile);
    }

    public List<MiniShopsResponse> getSubStoreByRegionIdsAndMobile(List<String> regionIdList, String mobile,String storeName,String storeNum) {
        if(StringUtils.isBlank(mobile)) {
            return new ArrayList<>();
        }
        return storeMapper.getSubStoreByRegionIdsAndMobile(regionIdList,mobile,storeName,storeNum);
    }


    public List<StoreDO> list(Integer isIot) {
        return storeMapper.list(isIot);
    }

    public List<StoreDO> getStoreNumByStoreCodes(List<String> storeCodeIds) {
        if(CollectionUtils.isEmpty(storeCodeIds)) {
            return Lists.newArrayList();
        }
        return storeMapper.getStoreNumByStoreCodes(storeCodeIds);
    }

    /**
     * 新增或编辑最新订货时间
     * @param dtoList 门店最新订货时间DTO列表
     * @return int
     */
    public void batchInsertOrUpdateOrderTime(List<StoreOrderTimeDTO> dtoList) {
        if (CollectionUtils.isEmpty(dtoList)) {
            return ;
        }
        storeMapper.batchInsertOrUpdateOrderTime(dtoList);
    }

    /**
     * 查询所有门店id和门店编码
     */
    public List<StoreDO> getAllStoreIdAndNum(List<String> storeStatus) {
        return storeMapper.getAllStoreIdAndNum(storeStatus);
    }

    /**
     * 查询门店积分
     * @param storeId 门店id
     * @return 积分
     */
    public BigDecimal getStoreScore(@Param("storeId") String storeId) {
        BigDecimal score = storeMapper.getStoreScore(storeId);
        if (Objects.isNull(score)) {
            return BigDecimal.valueOf(12.0);
        }
        return score;
    }

    /**
     * 根据门店id查询门店编码
     * @param storeIds 门店id列表
     * @return store_id -> score
     */
    public Map<String, BigDecimal> getScoreByStoreIds(List<String> storeIds) {
        if (CollectionUtils.isEmpty(storeIds)) {
            return Collections.emptyMap();
        }
        List<Map<String, Object>> list = storeMapper.getScoreByStoreIds(storeIds);
        return CollStreamUtil.toMap(list, v -> MapUtils.getString(v, "storeId"), v -> BigDecimal.valueOf(MapUtils.getDouble(v, "score")));
    }

    /**
     * 根据门店id查询门店映射
     * @param storeIds 门店id列表
     * @return 门店id->门店
     */
    public Map<String, StoreDO> getStoreMapByStoreIds(List<String> storeIds) {
        if (CollectionUtils.isEmpty(storeIds)) {
            return Collections.emptyMap();
        }
        List<StoreDO> storeList = storeMapper.getStoreByStoreIds(storeIds);
        return CollStreamUtil.toMap(storeList, StoreDO::getStoreId, v -> v);
    }

    /**
     * 更新门店积分
     * @param storeId 门店id
     * @param score 积分
     */
    public boolean updateStoreScore(String storeId, BigDecimal score) {
        return storeMapper.updateStoreScore(storeId, score) > 0;
    }
    /**
     * 修改门店营业状态
     * @param storeId 门店id
     * @param storeStatus 门店营业状态
     */
    public void updateStoreStatus(String storeId, String storeStatus,Date actualOpenDate) {
        if (Objects.isNull(storeId)||Objects.isNull(storeStatus)||Objects.isNull(actualOpenDate))
        storeMapper.updateStoreStatus(storeId,storeStatus,actualOpenDate);
    }

    /**
     * 暂停营业
     * @param storeId 门店id
     * @param closeUpReason 暂停营业原因
     */
    public void closeUp(String storeId, String closeUpReason) {
        if (storeMapper.updateStatus(storeId, StoreStatusEnum.CLOSE_UP.getValue()) > 0) {
            storeMapper.insertOrUpdateCloseUpReason(storeId, closeUpReason);
        }
    }

    /**
     * 暂停营业门店转在营
     */
    public void closeUpToOpen(String storeId) {
        if (storeMapper.updateStatus(storeId, StoreStatusEnum.OPEN.getValue()) > 0) {
            storeMapper.insertOrUpdateCloseUpReason(storeId, null);
        }
    }

    /**
     * 门店状态改为闭店
     * @param storeId 门店id
     * @param closeReason 闭店原因
     * @param closeNature 闭店性质
     */
    public void closeStore(String storeId, Integer closeReason, Integer closeNature, Date actualCloseData) {
        if (storeMapper.closeStore(storeId, actualCloseData) > 0) {
            storeMapper.insertOrUpdateCloseInfo(storeId, closeReason, closeNature);
        }
    }

    /**
     * 查询最近没有订货记录的门店
     * @param latestDate 最近订货时间
     * @param businessTypes 商圈类型
     * @param inBusinessType 在列表内
     * @return 门店列表
     */
    public List<StoreDO> getNoOrderStore(LocalDate latestDate, List<String> businessTypes, Boolean inBusinessType) {
        return storeMapper.getNoOrderStore(latestDate, businessTypes, inBusinessType);
    }

    /**
     * 根据行政区划查询门店数量统计
     * @param cityNames 市名称列表
     * @return <年, <季度, <省, <市, 门店数量>>>>
     */
    public Map<Integer, Map<Integer, Map<String, Map<String, Integer>>>> storeNumStatisticsByAd(List<Integer> years, List<String> cityNames) {
        if (CollectionUtils.isEmpty(cityNames)) {
            return Collections.emptyMap();
        }
        List<Map<String, Object>> maps = storeMapper.storeNumStatisticsByAd(years, cityNames);
        return maps.stream()
                .collect(Collectors.groupingBy(
                                v -> MapUtils.getInteger(v, "year"),
                                Collectors.groupingBy(
                                        v -> MapUtils.getInteger(v, "quarter"),
                                        Collectors.groupingBy(
                                                v -> MapUtils.getString(v, "province"),
                                                Collectors.toMap(
                                                        v -> MapUtils.getString(v, "city"),
                                                        v -> MapUtils.getInteger(v, "store_num", 0),
                                                        (o, n) -> o)
                                        )
                                )
                        )

                );
    }

    /**
     * 根据区域id查询门店列表
     * @param regionIds 区域id
     * @param keyword 门店名称或门店编码
     * @return 门店列表
     */
    public List<StoreDO> getStoreByRegionIds(List<String> regionIds, String keyword) {
        return storeMapper.getStoreByRegionIds(regionIds, keyword);
    }

    public List<StoreAddressDTO> getStoreAddress(Integer flag,String storeCode){
        return storeMapper.getStoreAddress(flag,storeCode);
    }

    public Integer batchUpdateAddress(List<StoreDO> storeList){
        if (CollectionUtils.isEmpty(storeList)){
            return 0;
        }
        return storeMapper.batchUpdateAddress(storeList);
    }

    /**
     * 获取私域二维码
     */
    public String getPrivateSphereQrCode(String storeId){
        return storeMapper.getPrivateSphereQrCode(storeId);
    }
}
