package project.ddos.internal;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;

import kernel.util.StringUtils;
import project.ddos.CheckIpRequestCountService;
import project.ddos.IpMenuService;
import project.ddos.UrlSpecialService;
import project.ddos.model.IpMenu;
import project.ddos.utils.BlacklistIpSerivceTimeWindow;
import project.ddos.utils.IpLockRequestTimeWindow;
import project.ddos.utils.IpRequestTimeWindow;
import project.ddos.utils.IpSpecialRequestTimeWindow;
import project.ddos.utils.LocklistIpSerivceTimeWindow;
import project.ddos.utils.SystemParaReadRequestTimeWindow;
import project.redis.RedisHandler;
import project.syspara.SysparaService;

public class CheckIpRequestCountServiceImpl implements CheckIpRequestCountService, InitializingBean {
    private Logger log = LoggerFactory.getLogger(CheckIpRequestCountServiceImpl.class);
    private IpRequestTimeWindow ipRequestTimeWindow;
    private IpSpecialRequestTimeWindow ipSpecialRequestTimeWindow;
    private BlacklistIpSerivceTimeWindow blacklistIpSerivceTimeWindow;

    private IpLockRequestTimeWindow ipLockRequestTimeWindow;
    private LocklistIpSerivceTimeWindow locklistIpSerivceTimeWindow;

    private SystemParaReadRequestTimeWindow systemParaReadRequestTimeWindow;
    private SysparaService sysparaService;
    private IpMenuService ipMenuService;
    private UrlSpecialService urlSpecialService;
    private RedisHandler redisHandler;

    /**
     * 是否开启ip检测
     */
    private String request_check_ip;
    /**
     * 验证ip请求数量限制（十分钟内）
     */
    private Integer request_check_ip_count;
    /**
     * 特殊url验证ip请求数量限制（一分钟内）
     */
    private Integer request_check_ip_special_count;
    /**
     * 是否只有白名单才可以访问
     */
    private boolean request_only_white_menu;
//	private String request_check_ip = "false";
//	private Integer request_check_ip_count = 500;
//	private Integer request_check_ip_special_count = 20;

    private Map<String, Integer> ipCache = new ConcurrentHashMap<String, Integer>();
    /**
     * 特殊地址ip处理
     */
    private Map<String, Integer> ipSpecialCache = new ConcurrentHashMap<String, Integer>();
    /**
     * 登录相关地址ip请求数，判定锁定处理
     */
    private Map<String, Integer> ipLockCache = new ConcurrentHashMap<String, Integer>();
    /**
     * ip请求数本地缓存，从服务器启动时开始计数
     */
    private Map<String, AtomicLong> ipCountCache = new ConcurrentHashMap<String, AtomicLong>();
    /**
     * ip请求时间本地缓存，从服务器启动时开始
     */
    private Map<String, Date> ipTimeCacheCache = new ConcurrentHashMap<String, Date>();
    /**
     * ip urls请求数本地缓存，从服务器启动时开始计数
     */
    private Map<String, Map<String, AtomicLong>> ipUrlCountCache = new ConcurrentHashMap<String, Map<String, AtomicLong>>();
    /**
     * 登录页相关所需的urls
     */
    private List<String> urls = new ArrayList<String>();

    /**
     * ip访问计数
     *
     * @param ip
     */
    private void ipCount(String ip, String url) {
        AtomicLong atomicLong = ipCountCache.get(ip);
        Map<String, AtomicLong> urlCountMap = ipUrlCountCache.get(ip);
        if (urlCountMap == null) {
            urlCountMap = new ConcurrentHashMap<String, AtomicLong>();
        }
        if (atomicLong == null) {
            atomicLong = new AtomicLong();
            ipTimeCacheCache.put(ip, new Date());
            atomicLong.incrementAndGet();
            ipCountCache.put(ip, atomicLong);
            // 累计url次数

            AtomicLong atomicUrlLong = new AtomicLong();
            atomicUrlLong.incrementAndGet();
            urlCountMap.put(url, atomicUrlLong);
            ipUrlCountCache.put(ip, urlCountMap);
        } else {
            atomicLong.incrementAndGet();
            // 累计url次数
            AtomicLong atomicUrlLong = urlCountMap.get(url);
            if (atomicUrlLong == null) {
                atomicUrlLong = new AtomicLong();
                atomicUrlLong.incrementAndGet();
                urlCountMap.put(url, atomicUrlLong);
                ipUrlCountCache.put(ip, urlCountMap);
            } else {
                atomicUrlLong.incrementAndGet();
            }
//			System.out.println("ip:" + ip + ",url:" + url + ",count:" + atomicUrlLong.get());
        }
//		System.out.println("ip:" + ip + ",count:" + atomicLong.get());
    }

    /**
     * 是否开启检测功能
     *
     * @return
     */
    public boolean checkButton() {
        if (StringUtils.isEmptyString(systemParaReadRequestTimeWindow.get("systemParaRead"))) {
            readPara();
            systemParaReadRequestTimeWindow.put("systemParaRead", "1");
        }
        return "true".equals(request_check_ip);
    }

    public void readPara() {
        String old_request_check_ip = request_check_ip;
        int old_request_check_ip_count = request_check_ip_count;
        int old_request_check_ip_special_count = request_check_ip_special_count;
        boolean old_request_only_white_menu = request_only_white_menu;
        request_check_ip = sysparaService.find("request_check_ip").getValue();
        request_check_ip_count = sysparaService.find("request_check_ip_count").getInteger();
        request_check_ip_special_count = sysparaService.find("request_check_ip_special_count").getInteger();
        request_only_white_menu = sysparaService.find("request_only_white_menu").getBoolean();
        if (!old_request_check_ip.equals(request_check_ip)) {
            log.info("request_check_ip 修改，原值:[{}],新值[{}]", old_request_check_ip, request_check_ip);
        }
        if (old_request_check_ip_count != request_check_ip_count) {
            log.info("request_check_ip_count 修改，原值:[{}],新值[{}]", old_request_check_ip_count, request_check_ip_count);
        }
        if (old_request_check_ip_special_count != request_check_ip_special_count) {
            log.info("request_check_ip_special_count 修改，原值:[{}],新值[{}]", old_request_check_ip_special_count,
                    request_check_ip_special_count);
        }
        if (old_request_only_white_menu != request_only_white_menu) {
            log.info("request_only_white_menu 修改，原值:[{}],新值[{}]", old_request_only_white_menu, request_only_white_menu);
        }

    }

    /**
     * 返回true:ip已被封， false：ip正常
     *
     * @param ip
     * @return
     */
    @Override
    public boolean chcekIp(String ip, String url) {
//		String request_check_ip = sysparaService.find("request_check_ip").getValue();
//		Integer request_check_ip_count = sysparaService.find("request_check_ip_count").getInteger();
        if (!"true".equals(request_check_ip))
            return false;// 不为1时 未开启，直接返回false不做处理
        ipCount(ip, url);
        IpMenu ipMenu = ipMenuService.cacheByIp(ip);
        if (ipMenu != null && ipMenu.getDelete_status() != -1 && IpMenu.IP_WHITE.equals(ipMenu.getType())) {// 白名单直接过
            return false;
        } else if (request_only_white_menu) {
            return true;
        }
        if (checkLockUrl(ip, url)) {// 先判断是否锁定
            return true;
        }
        if (blacklistIpSerivceTimeWindow.getBlackIp(ip) != null)
            return true;// ip被封，不发送
        if (ipMenu != null && ipMenu.getDelete_status() != -1 && IpMenu.IP_BLACK.equals(ipMenu.getType())) {// 黑名单已过期的
            ipMenu.setDelete_status(-1);
            ipMenuService.update(ipMenu);
        }
        if (ipRequestTimeWindow.getIpSend(ip) != null) {
            Integer count = ipCache.get(ip);
//			System.out.println("ip:" + ip + ",count:" + count);
            count++;
            if (count >= request_check_ip_count) {// 从ip发送第一条开始
                // System.out.println("ip:" + ip + ",count:" + count);
//				blacklistIpSerivceTimeWindow.putBlackIp(ip, ip);
                ipCache.remove(ip);
                ipRequestTimeWindow.delIpSend(ip);

                if (null == ipMenu) {
                    ipMenu = new IpMenu();
                    ipMenu.setCreate_time(new Date());
                    ipMenu.setDelete_status(0);
                    ipMenu.setLast_opera_time(new Date());
                    ipMenu.setType(IpMenu.IP_BLACK);
                    ipMenu.setIp(ip);
                    ipMenuService.save(ipMenu);
                } else {
                    ipMenu.setDelete_status(0);
                    ipMenu.setLast_opera_time(new Date());
                    ipMenu.setType(IpMenu.IP_BLACK);
                    ipMenuService.update(ipMenu);
                }
                return true;
            } else {
                ipCache.put(ip, count++);
            }

        } else {
            ipCache.put(ip, 1);
            ipRequestTimeWindow.putIpSend(ip, ip);
        }
        if (checkSpecialUrl(ip, url)) {
            return true;
        }

        return false;

    }

    /**
     * 检验特殊url处理 返回true:ip已被封， false：ip正常
     *
     * @param ip
     * @return
     */
    public boolean checkSpecialUrl(String ip, String url) {
//		Integer request_check_ip_special_count = sysparaService.find("request_check_ip_special_count").getInteger();
        if (!urlSpecialService.cacheAllUrls().contains(url)) {
            return false;
        }
        if (ipSpecialRequestTimeWindow.getIpSend(ip) != null) {
            Integer count = ipSpecialCache.get(ip);
//			System.out.println("ip:" + ip + ",count:" + count);
            count++;
            if (count >= request_check_ip_special_count) {// 从ip发送第一条开始

//				blacklistIpSerivceTimeWindow.putBlackIp(ip, ip);
                ipSpecialCache.remove(ip);
                ipSpecialRequestTimeWindow.delIpSend(ip);

                IpMenu ipMenu = ipMenuService.cacheByIp(ip);
                if (null == ipMenu) {
                    ipMenu = new IpMenu();
                    ipMenu.setCreate_time(new Date());
                    ipMenu.setDelete_status(0);
                    ipMenu.setLast_opera_time(new Date());
                    ipMenu.setType(IpMenu.IP_BLACK);
                    ipMenu.setIp(ip);
                    ipMenuService.save(ipMenu);
                } else {
                    ipMenu.setDelete_status(0);
                    ipMenu.setLast_opera_time(new Date());
                    ipMenu.setType(IpMenu.IP_BLACK);
                    ipMenuService.update(ipMenu);
                }
                return true;
            } else {
                ipSpecialCache.put(ip, count++);
            }

        } else {
            ipSpecialCache.put(ip, 1);
            ipSpecialRequestTimeWindow.putIpSend(ip, ip);
        }
        return false;
    }

    /**
     * 检验锁定相关url处理 返回true:ip已被封， false：ip正常
     *
     * @param ip
     * @return
     */
    public boolean checkLockUrl(String ip, String url) {
        if (!urls.contains(url)) {
            return false;
        }
        if (ipLockRequestTimeWindow.getIpSend(ip) != null) {
            Integer count = this.ipLockCache.get(ip);
//			System.out.println("ip:" + ip + ",count:" + count);
            count++;
            if (count >= request_check_ip_count) {// 从ip发送第一条开始

//				blacklistIpSerivceTimeWindow.putBlackIp(ip, ip);
                ipLockCache.remove(ip);
                ipLockRequestTimeWindow.delIpSend(ip);

                IpMenu ipMenu = ipMenuService.cacheByIp(ip);
                if (null == ipMenu) {
                    ipMenu = new IpMenu();
                    ipMenu.setCreate_time(new Date());
                    ipMenu.setDelete_status(0);
                    ipMenu.setLast_opera_time(new Date());
                    ipMenu.setType(IpMenu.IP_LOCK);
                    ipMenu.setIp(ip);
                    ipMenuService.save(ipMenu);
                } else {
                    ipMenu.setDelete_status(0);
                    ipMenu.setLast_opera_time(new Date());
                    ipMenu.setType(IpMenu.IP_LOCK);
                    ipMenuService.update(ipMenu);
                }
                return true;
            } else {
                ipLockCache.put(ip, count++);
            }

        } else {
            ipLockCache.put(ip, 1);
            ipLockRequestTimeWindow.putIpSend(ip, ip);
        }
        return false;
    }

    public Map<String, AtomicLong> getIpCountCache() {
        return ipCountCache;
    }

    public Map<String, Date> getIpTimeCacheCache() {
        return ipTimeCacheCache;
    }

    public void clearIpCountCache() {
        ipCountCache.clear();
    }

    public void clearIpTimeCacheCache() {
        ipTimeCacheCache.clear();
    }

    /**
     * 分页获取ip计数相关信息，（防止因跨服务请求导致网络带宽不足而响应慢）
     *
     * @param pageNo
     * @param pageSize
     * @param ip_para
     * @param type_para
     * @param limit_count
     * @param isExcludeBlack true:排除黑名单
     * @return
     */
    public List<Map<String, Object>> cachePagedQueryIpCount(int pageNo, int pageSize, String ip_para, String type_para,
                                                            Long limit_count, boolean isExcludeMenu) {
        Map<String, AtomicLong> ipCountCache = this.getIpCountCache();
        Map<String, Date> ipTimeCacheCache = this.getIpTimeCacheCache();
        List<Map<String, Object>> pageList = new ArrayList<Map<String, Object>>();
        for (Entry<String, AtomicLong> entry : ipCountCache.entrySet()) {
            if (StringUtils.isNotEmpty(ip_para) && entry.getKey().indexOf(ip_para) == -1) {// ip赛选条件
                continue;
            }
            IpMenu ipMenu = ipMenuService.cacheByIp(entry.getKey());
            if (StringUtils.isNotEmpty(type_para) && ipMenu != null && !type_para.equals(ipMenu.getType())
                    && ipMenu.getDelete_status() == 0) {// 类型赛选条件
                continue;
            }
            if (isExcludeMenu && ipMenu != null && ipMenu.getDelete_status() == 0) {// 是否排除黑名单
                continue;
            }
            if (limit_count != null && limit_count > entry.getValue().get()) {
                continue;
            }
            Map<String, Object> data = new HashMap<String, Object>();
            data.put("ip", entry.getKey());
            data.put("count", entry.getValue().get());
            data.put("create_time", ipTimeCacheCache.get(entry.getKey()));
            data.put("type", ipMenu == null || ipMenu.getDelete_status() == -1 ? null : ipMenu.getType());
            pageList.add(data);
        }
        if (pageList.isEmpty()) {
            return new LinkedList<Map<String, Object>>();
        }
        java.util.Collections.sort(pageList, new Comparator<Map<String, Object>>() {
            @Override
            public int compare(Map<String, Object> paramT1, Map<String, Object> paramT2) {
                // TODO Auto-generated method stub
                Long t1 = Long.valueOf(paramT1.get("count").toString());
                Long t2 = Long.valueOf(paramT2.get("count").toString());
                return -t1.compareTo(t2);
            }
        });

        int start = (pageNo - 1) * pageSize;
        start = start <= 0 ? 0 : start;//
        int end = start + pageSize;

        if (start >= pageList.size()) {// 起始数据大于总量，返回空
            return new LinkedList<Map<String, Object>>();
        }
        if (pageList.size() <= end)
            end = pageList.size();

        List<Map<String, Object>> list = pageList.subList(start, end);
        return list;
    }

    /**
     * 根据ips批量获取对应的请求数据，减少交互
     *
     * @param ips
     * @return
     */
    public Map<String, Long> ipCountByIps(List<String> ips) {
        Map<String, Long> map = new HashMap<String, Long>();
        for (String ip : ips) {
            map.put(ip, !this.ipCountCache.containsKey(ip) ? 0L : ipCountCache.get(ip).get());
        }

        return map;
    }

    /**
     * 获取ip请求汇总数据
     *
     * @return
     */
    public Map<String, Object> ipCountSumDates() {
        Map<String, Object> map = new HashMap<String, Object>();
        Long sumRequest = 0l;
        Long sumIp = 0l;
        for (Entry<String, AtomicLong> entry : ipCountCache.entrySet()) {
            IpMenu ipMenu = ipMenuService.cacheByIp(entry.getKey());
            if (ipMenu != null && ipMenu.getDelete_status() == 0) {// 排除名单
                continue;
            }
            sumIp++;
            sumRequest += entry.getValue().get();
        }
        map.put("ip_request_sum", sumRequest);
        map.put("ip_sum", sumIp);
        return map;
    }

    public void afterPropertiesSet() throws Exception {
        request_check_ip = sysparaService.findByDB("request_check_ip").getValue();
        request_check_ip_count = sysparaService.findByDB("request_check_ip_count").getInteger();
        request_check_ip_special_count = sysparaService.findByDB("request_check_ip_special_count").getInteger();
        request_only_white_menu = sysparaService.findByDB("request_only_white_menu").getBoolean();
        initLoginPageRelationAction();
    }

    public void initLoginPageRelationAction() {
//		/pages/login/index登录页：1、api/syspara.action 2、api/user!login.action 
        urls.add("/api/syspara.action");
        urls.add("/api/user!login.action");
//		/pages/login/forget找回密码：1、api/syspara.action 2、api/user!resetpswByGoogle 3、api/user!resetpsw.action 4、api/idcode!execute.action 5、api/user!getUserNameVerifTarget
//		urls.add("/api/syspara.action");
        urls.add("/api/user!resetpswByGoogle.action");
        urls.add("/api/user!resetpsw.action");
        urls.add("/api/idcode!execute.action");
        urls.add("/api/api/user!getUserNameVerifTarget.action");
//		/pages/login/register-new注册页面：1、api/localuser!getImageCode 2、api/idcode!execute 3、api/localuser!register_username 4、api/localuser!register
        urls.add("/api/localuser!getImageCode.action");
        urls.add("/api/idcode!execute.action");
        urls.add("/api/localuser!register_username.action");
        urls.add("/api/localuser!register.action");
//		/pages/user/server客服 1、api/onlinechat!list.action 2、api/onlinechat!send 3、api/onlinechat!unread
        urls.add("/api/onlinechat!list.action");
        urls.add("/api/onlinechat!send.action");
        urls.add("/api/onlinechat!unread.action");
    }

    /**
     * 登录页相关所需的urls
     */
    public List<String> loginPageRelationAction() {
        return urls;
    }

    public Map<String, AtomicLong> cacheUrlCount(String ip) {
        return ipUrlCountCache.get(ip);
    }

    /**
     * ip请求数相关缓存清除
     *
     * @param ip
     */
    public void cacheRemoveIp(String ip) {
        this.ipCountCache.remove(ip);
        this.ipTimeCacheCache.remove(ip);
        this.ipUrlCountCache.remove(ip);

        /**
         * 对应的时间窗ip清除
         */
        ipRequestTimeWindow.delIpSend(ip);
        ipSpecialRequestTimeWindow.delIpSend(ip);
        ipLockRequestTimeWindow.delIpSend(ip);

        ipLockCache.remove(ip);
        ipCache.remove(ip);
        ipSpecialCache.remove(ip);

    }

    /**
     * ip请求清除不在名单里的数据
     */
    public void cacheRequestClearNoMenu() {
        for (String key : ipCountCache.keySet()) {
            IpMenu ipMenu = ipMenuService.cacheByIp(key);
            if (ipMenu != null && ipMenu.getDelete_status() == 0) {// 排除名单
                continue;
            }
//			this.ipCountCache.remove(key);
//			this.ipTimeCacheCache.remove(key);
//			this.ipUrlCountCache.remove(key);
            cacheRemoveIp(key);
        }
    }

    @Override
    public boolean checkBlackIp(String ip) {
//        log.info("检查IP黑名单：{}", ip);
        if (!"true".equals(request_check_ip)) {
            return false;// 不为1时 未开启，直接返回false不做处理}
        }
//        ipCount(ip, url);
        IpMenu ipMenu = ipMenuService.cacheByIp(ip);
		// 黑名单已过期的
		return ipMenu != null && ipMenu.getDelete_status() != -1 && IpMenu.IP_BLACK.equals(ipMenu.getType());// ip被封，不发送

	}

    /**
     * ip是否锁定
     *
     * @param ip
     * @return
     */
    public boolean isLock(String ip) {
        return locklistIpSerivceTimeWindow.getLockIp(ip) != null;
    }

    public void setIpRequestTimeWindow(IpRequestTimeWindow ipRequestTimeWindow) {
        this.ipRequestTimeWindow = ipRequestTimeWindow;
    }

    public void setBlacklistIpSerivceTimeWindow(BlacklistIpSerivceTimeWindow blacklistIpSerivceTimeWindow) {
        this.blacklistIpSerivceTimeWindow = blacklistIpSerivceTimeWindow;
    }

    public void setSysparaService(SysparaService sysparaService) {
        this.sysparaService = sysparaService;
    }

    public void setIpMenuService(IpMenuService ipMenuService) {
        this.ipMenuService = ipMenuService;
    }

    public void setIpSpecialRequestTimeWindow(IpSpecialRequestTimeWindow ipSpecialRequestTimeWindow) {
        this.ipSpecialRequestTimeWindow = ipSpecialRequestTimeWindow;
    }

    public void setUrlSpecialService(UrlSpecialService urlSpecialService) {
        this.urlSpecialService = urlSpecialService;
    }

    public void setRedisHandler(RedisHandler redisHandler) {
        this.redisHandler = redisHandler;
    }

    public void setSystemParaReadRequestTimeWindow(SystemParaReadRequestTimeWindow systemParaReadRequestTimeWindow) {
        this.systemParaReadRequestTimeWindow = systemParaReadRequestTimeWindow;
    }

    public void setIpLockRequestTimeWindow(IpLockRequestTimeWindow ipLockRequestTimeWindow) {
        this.ipLockRequestTimeWindow = ipLockRequestTimeWindow;
    }

    public void setLocklistIpSerivceTimeWindow(LocklistIpSerivceTimeWindow locklistIpSerivceTimeWindow) {
        this.locklistIpSerivceTimeWindow = locklistIpSerivceTimeWindow;
    }

}