package com.fzzy.sys;

import com.fzzy.api.utils.ContextUtil;
import com.fzzy.sys.entity.LogLogin;
import com.fzzy.api.utils.RedisConst;
import com.fzzy.api.utils.RedisUtil;
import com.fzzy.api.utils.SystemUtil;
import com.fzzy.sys.repository.LogLoginRep;
import com.fzzy.sys.entity.SysUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.util.Date;

/**
 * @Desc: 登陆日志记录信息
 * @author: andy.jia
 * @update-time: 2023/4/28 8:32
 */
@Component
public class LogLoginService{

    private String KEY_LOGON_LOG = "LOGIN_LOG";
    private int TIME_ERROR_MIN = 60;

    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private LogLoginRep logLoginRep;

    /**
     * 判断当前登陆是否被限制
     *
     * @param request
     * @param username
     * @return
     */
    public int checkLoginLimit(HttpServletRequest request, String username) {

        //获取错误记录缓存
        LogLogin errorLog = this.getFromCacheError(username, SystemUtil.getIP(request));

        if (null == errorLog) return 0;

        return errorLog.getErrorNum();
    }


    /**
     * 密码输入错误记录，返回输入错误次数
     *
     * @param request
     * @param user
     * @return
     */
    public int addPwdError(HttpServletRequest request, SysUser user) {
        LogLogin log = new LogLogin();
        log.setCompanyId(user.getCompanyId());
        log.setLoginId(user.getUsername());
        log.setLoginName(user.getName());
        log.setLoginTime(new Date());
        log.setIp(SystemUtil.getIP(request));
        log.setBrowser(SystemUtil.getBrowserInfo(request));
        log.setSysName(SystemUtil.getSystemInfo(request));
        log.setHostName(SystemUtil.getHostName(log.getIp()));
        log.setLastLoginTime(new Date());
        log.setErrorNum(1);
        log.setLoginInfo("失败：密码错误");

        // 获取上次错误记录
        LogLogin errorLog = this.getFromCacheError(user.getUsername(), log.getIp());
        if (null != errorLog) {
            log.setErrorNum(errorLog.getErrorNum() + 1);
        }

        //保存日志
        addLog(log);

        //保存到缓存
        addToCacheError(log);

        return log.getErrorNum();
    }


    /**
     * 登陆用户不存在错误，返回输入不存在账号次数，用户不存在的账号，使用IP作为判断标准，避免恶意尝试
     *
     * @param request
     * @param username
     * @return
     */
    public int addNoUser(HttpServletRequest request, String username) {

        LogLogin log = new LogLogin();
        log.setLoginName(username);
        log.setLoginTime(new Date());
        log.setIp(SystemUtil.getIP(request));
        log.setBrowser(SystemUtil.getBrowserInfo(request));
        log.setSysName(SystemUtil.getSystemInfo(request));
        log.setHostName(SystemUtil.getHostName(log.getIp()));
        log.setLastLoginTime(new Date());
        log.setErrorNum(1);
        log.setLoginId(log.getIp());
        log.setLoginInfo("失败：无效账号");

        // 获取上次错误记录
        LogLogin errorLog = this.getFromCacheError(log.getIp(), log.getIp());
        if (null != errorLog) {
            log.setErrorNum(errorLog.getErrorNum() + 1);
        }

        //保存到缓存
        addToCache(log);


        //保存日志
        log.setLoginId(username);
        addLog(log);

        return log.getErrorNum();
    }

    /**
     * 增加登陆日志信息
     *
     * @param request
     * @param user
     */
    public void addLoginInfo(HttpServletRequest request, SysUser user) {
        LogLogin log = new LogLogin();
        log.setCompanyId(user.getCompanyId());
        log.setLoginId(user.getUsername());
        log.setLoginName(user.getName());
        log.setLoginTime(new Date());
        log.setIp(SystemUtil.getIP(request));
        log.setBrowser(SystemUtil.getBrowserInfo(request));
        log.setSysName(SystemUtil.getSystemInfo(request));
        log.setHostName(SystemUtil.getHostName(log.getIp()));
        log.setErrorNum(0);
        log.setLoginInfo("成功：正常登陆");

        // 获取上次登陆信息
        LogLogin lastLog = this.getFromCache(log.getLoginId());
        if (null != lastLog) {
            log.setLastLoginTime(lastLog.getLoginTime());
        }

        //保存缓存
        addToCache(log);

        //保存日志
        addLog(log);
    }

    /**
     * @param log
     */
    private void addToCache(LogLogin log) {

        String key = RedisConst.buildKey(KEY_LOGON_LOG, log.getLoginId());

        redisUtil.set(key, log);


        this.removeCacheError(log.getLoginId(), log.getIp());

    }


    private LogLogin getFromCache(String loginId) {
        if (null == loginId) return null;
        try {
            String key = RedisConst.buildKey(KEY_LOGON_LOG, loginId);
            return (LogLogin) redisUtil.get(key);
        } catch (Exception e) {
            return null;
        }
    }

    private void removeCacheError(String loginId, String ip) {
        String key = RedisConst.buildKey(KEY_LOGON_LOG, loginId, ip);

        redisUtil.del(key);
    }

    private void addToCacheError(LogLogin log) {
        String key = RedisConst.buildKey(KEY_LOGON_LOG, log.getLoginId(), log.getIp());
        redisUtil.set(key, log, (TIME_ERROR_MIN + 1) * 60);
    }

    private LogLogin getFromCacheError(String loginId, String ip) {
        if (null == loginId) return null;
        if (null == ip) return null;
        try {
            String key = RedisConst.buildKey(KEY_LOGON_LOG, loginId, ip);
            return (LogLogin) redisUtil.get(key);
        } catch (Exception e) {
            return null;
        }
    }


    /**
     * @Desc: 保存日志
     * @author: Andy
     * @update-time: 2023/4/28
     */
    public void addLog(LogLogin log) {

        if (null == log) return;

        if (null == log.getId()) {
            log.setId(ContextUtil.getUUID());
        }
        logLoginRep.save(log);
    }

}