package com.mzl.flower.config;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.mzl.flower.mapper.ip.BlackListMapper;
import com.mzl.flower.entity.ip.BlackList;
import com.mzl.flower.utils.IpUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Component
@Slf4j
public class SlidingWindowInterceptor implements HandlerInterceptor {

    /**
     * 限流周期
     */
    private int RATE_CYCLE = 10;

    /**
     * 单位时间划分的小周期
     */
    private int SUB_CYCLE = 10;
    /**
     * 限流请求数
     */
    private int thresholdPerCycle = 50;
    /**
     * 计数器, k-ip，value-当前窗口的开始时间值秒及当前窗口的计数
     */
    private final ConcurrentHashMap<String, ConcurrentHashMap<Long, Integer>> ipCounters = new ConcurrentHashMap<>();


    private final BlackListMapper blackListMapper;

    public SlidingWindowInterceptor(BlackListMapper blackListMapper) {
        this.blackListMapper = blackListMapper;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        LocalDateTime now = LocalDateTime.now();
        String ip = null;
        try {
            ip = IpUtil.getIpAddress(request);
        } catch (IOException e) {
            log.error("获取ip失败",e);
            ip = request.getRemoteAddr();
        }
        if(checkBlackList(ip)){ //验证黑名单
            try {
                response.sendError(HttpStatus.SERVICE_UNAVAILABLE.value(), "IP被禁用，请联系管理员！");
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            log.error("禁用IP发送请求被拦截，请求ip="+ip);
        }
        boolean result = slidingWindowsTryAcquire(ip,now);
        if(!result){
            try {
                response.sendError(HttpStatus.TOO_MANY_REQUESTS.value(), "系统操作太频繁，请稍后再试！");
                log.error("请求太频繁ip="+ip);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            return false;
        }
        return true;
    }

    private boolean checkBlackList(String ip) {
        if (StringUtils.isNotBlank(ip)) {
            return blackListMapper.selectCount(new LambdaQueryWrapper<BlackList>().eq(BlackList::getIp, ip)) > 0;
        }
       return false;
    }

    /**
     * 滑动窗口时间算法实现
     */
    boolean slidingWindowsTryAcquire(String ip, LocalDateTime now) {
        long currentWindowTime = now.toEpochSecond(ZoneOffset.UTC) / SUB_CYCLE * SUB_CYCLE; //获取当前时间在哪个小周期窗口
        int currentWindowNum = countCurrentWindow(currentWindowTime,ip); //当前窗口总请求数
        //超过阀值限流
        if (currentWindowNum >= thresholdPerCycle) {
            return false;
        }
        //计数器+1
        ConcurrentHashMap<Long, Integer> counters = ipCounters.get(ip);
        if(counters == null){
            counters = new ConcurrentHashMap<>();
        }
        counters.put(currentWindowTime, counters.getOrDefault(currentWindowTime, 0) + 1);
        ipCounters.put(ip,counters);
        return true;
    }
    /**
     * 统计当前窗口的请求数
     */
    private int countCurrentWindow(long currentWindowTime,String ip) {
        //计算窗口开始位置
        long startTime = currentWindowTime - SUB_CYCLE * (RATE_CYCLE / SUB_CYCLE-1);
        int count = 0;
        //遍历存储的计数器
        ConcurrentHashMap<Long, Integer> counters = ipCounters.get(ip);
        if(counters == null){
            return 0;
        }
        Iterator<Map.Entry<Long, Integer>> iterator = counters.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Long, Integer> entry = iterator.next();
            // 删除无效过期的子窗口计数器
            if (entry.getKey() < startTime) {
                iterator.remove();
            } else {
                //累加当前窗口的所有计数器之和
                count =count + entry.getValue();
            }
        }
        return count;
    }
}