package com.vci.web.service.impl;

import com.vci.client.mw.ClientSessionUtility;
import com.vci.constant.CacheNameConstant;
import com.vci.corba.common.PLException;
import com.vci.corba.common.data.InvocationInfo;
import com.vci.corba.omd.data.AttributeValue;
import com.vci.starter.web.annotation.log.VciUnLog;
import com.vci.starter.web.constant.TokenKeyConstant;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.interceptor.VciSessionForLoginI;
import com.vci.starter.web.pagemodel.SessionInfo;
import com.vci.starter.web.pagemodel.TokenVO;
import com.vci.starter.web.redis.RedisService;
import com.vci.starter.web.util.*;
import com.vci.web.properties.WebProperties;
import com.vci.web.service.WebBoServiceI;
import com.vci.web.util.PlatformClientUtil;
import com.vci.web.util.WebUtil;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * 会话存储的服务
 * @author weidy
 * @date 2021/2/18
 */
@Service
@VciUnLog
public class SmSessionForLoginImpl implements VciSessionForLoginI {

    /**
     * 日志
     */
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 配置信息
     */
    @Autowired
    private WebProperties webProperties;

    /**
     * 业务类型服务
     */
    @Autowired
    private WebBoServiceI boService;

    /**
     * 平台的调用类
     */
    @Autowired
    private PlatformClientUtil platformClientUtil;

    /**
     * redis服务
     */
    @Resource
    private RedisService redisService;

    /**
     * 检查用户是否登录
     *
     * @param userId 用户名
     * @return 为空表示没有登录
     */
    @Override
    public String checkIsLogined(String userId) {
        WebUtil.alertNotNull(userId,"用户名");
        List<Map> dataList = boService.queryBySqlForMap("select JSONSTRING as JSONSTRING from VCI_SESSIONINFO where userid ='" + userId.trim() + "'", new HashMap<>());
        if(!CollectionUtils.isEmpty(dataList)) {
            Map data = dataList.get(0);
            SessionInfo sessionInfo = WebUtil.jsonString2JavaBean((String)data.getOrDefault("JSONSTRING",""),SessionInfo.class);
            return "在ip为" + sessionInfo.getIp() + "的地方已经登录";
        }
        return "";
    }

    /**
     * 强制用户下线
     *
     * @param userId 用户名
     */
    @Override
    public void popUser(String userId) {
        WebUtil.alertNotNull(userId,"用户名");
        try{
            platformClientUtil.getBOFactoryService().executeUpdateSql("delete from VCI_SESSIONINFO where userid ='" + userId.trim() + "'");
        }catch (PLException e){
            throw WebUtil.getVciBaseException(e);
        }
    }

    /**
     * 将会话信息存储到数据库中------
     *
     * @param sessionInfo 会话信息
     */
    @Override
    @Deprecated
    public void saveSessionInfo(SessionInfo sessionInfo) {
        WebUtil.alertNotNull(sessionInfo,"会话信息");
        try {
            AttributeValue[] attrs = new AttributeValue[3];
            attrs[0] = new AttributeValue("0", sessionInfo.getUserId());
            attrs[1] = new AttributeValue("1", sessionInfo.getToken());
            attrs[2] = new AttributeValue("2", WebUtil.getJSONStringWithDateFormat(sessionInfo));
            platformClientUtil.getBOFactoryService().executeUpdateSqlByParams("    insert into VCI_SESSIONINFO (USERID, TOKEN, JSONSTRING,lastRequestTime\n" +
                    "      )\n" +
                    " VALUES (?,?,?," + System.currentTimeMillis() + " )", attrs);
        }catch (PLException e){
            throw WebUtil.getVciBaseException(e);
        }
    }

    /**
     * 校验请求是否符合权限验证
     * 包含1，系统是否可以访问当前服务或者接口
     * 2, 用户是否有权限访问当前服务
     * 3, 用户是否有权限访问当前数据
     *
     * @param request            请求对象
     * @param systemPrivateToken 系统的许可码
     * @param sessionInfo        当前用户会话对象
     * @param handler            执行对象
     * @return true表示有权限，false表示没权限
     * @throws VciBaseException 没有权限的时候会抛出异常
     */
    @Override
    public boolean checkRequestRights(HttpServletRequest request, String systemPrivateToken, SessionInfo sessionInfo, Object handler) throws VciBaseException {
        return true;
    }

    /**
     * 更新请求时间
     *
     * @param userToken 用户token
     */
    @Override
    public void updateRequestTime(String userToken) {
        WebUtil.alertNotNull(userToken,"会话许可码");
        //说明是jwt的token
        String jwtToken = getSessionTokenKeyInRedis(userToken);
        if(StringUtils.isBlank(jwtToken)){
            jwtToken = userToken;
        }
        SessionInfo sessionInfo = redisService.getCacheObject(jwtToken);
        sessionInfo.setLastLoginTime(VciDateUtil.getNowTime());
        redisService.setCacheObject(jwtToken, sessionInfo, webProperties.getClientSessionAliveMax()!=0?webProperties.getClientSessionAliveMax(): TokenKeyConstant.EXPIRATION, TimeUnit.MINUTES);
    }

    /**
     * 根据token获取用户的对象
     *
     * @param userToken 用户token
     * @return 用户会话对象
     */
    @Override
    public SessionInfo getSessionInfoByToken(String userToken) {
        WebUtil.alertNotNull(userToken,"许可的信息");
        SessionInfo sessionInfo = null;
        if(StringUtils.isNotBlank(userToken)){
            if(userToken.startsWith(TokenKeyConstant.TOKEN_KEY_PREFIX_IN_REDIS)){
                sessionInfo = redisService.getCacheObject(userToken);
                if(sessionInfo == null){
                    throw new VciBaseException("token已过期！");
                }
            }else{
                //说明是jwt的token
                String jwtToken = getSessionTokenKeyInRedis(userToken);
                if(StringUtils.isBlank(jwtToken)){
                    jwtToken = userToken;
                }
                sessionInfo = redisService.getCacheObject(jwtToken);
                if(sessionInfo == null){
                    throw new VciBaseException("token已过期！");
                }
            }
        }
        return sessionInfo;
    }

    /**
     * 退出登录
     * 清除用户session
     * @param userToken 用户的会话许可
     */
    @Override
    public void logout(String userToken,String userId) throws PLException {
        //TODO 根据情况，单独处理
        redisService.deleteObject(CacheNameConstant.USERID_TOKEN_KEY + userId);
        redisService.deleteObject(TokenKeyConstant.TOKEN_KEY_PREFIX_IN_REDIS + userToken);
        platformClientUtil.getFrameworkService().logoff(userToken);
    }

    /**
     * 根据token获取用户在系统中还可以存在的时间
     * @param userToken userToken 用户的会话许可
     * @return 用户在系统中还可以存在的时间(毫秒)
     */
    @Override
    public long getCanAliveTime(String userToken) {
        VciBaseUtil.alertNotNull(userToken,"用户会话许可（令牌)");
        List<Map> dataList = boService.queryBySqlForMap("select lastRequestTime as LASTREQUESTTIME from VCI_SESSIONINFO where TOKEN ='" + userToken.trim() + "'", new HashMap<>());
        if(!CollectionUtils.isEmpty(dataList)) {
            Map data = dataList.get(0);
            long lastTime = WebUtil.getLong(data.get("LASTREQUESTTIME").toString());
            long currentTime = System.currentTimeMillis();
            long canAliveTime = lastTime + (webProperties.getClientSessionAliveMax()*60*1000) - currentTime;
            return canAliveTime;
        }
        return 0;
    }

    /**
     * 删除超时的会话的信息
     */
    @Scheduled(fixedDelay=60000)
    public void deleteTimeoutSession(){
        long now = System.currentTimeMillis();
        if(webProperties.getClientSessionAliveMax() > 0) {
            long lastValidTime = now - webProperties.getClientSessionAliveMax() * 60000;
            if (logger.isDebugEnabled()) {
                logger.debug("开始执行扫描超时的会话信息,其中当前时间为{},会话最后访问的有效时间应该为{}", now, lastValidTime);
            }
            List<Map> invalidSessionList = boService.queryBySqlForMap("select token as TOKEN from  VCI_SESSIONINFO where lastRequestTime<= " + lastValidTime, null);
            if (!CollectionUtils.isEmpty(invalidSessionList)) {
                List<String> tokenList = new ArrayList<>();
                invalidSessionList.stream().forEach(map -> {
                    tokenList.add(map.get("TOKEN").toString());
                });
                WebUtil.switchCollectionForOracleIn(tokenList).stream().forEach(tokens -> {
                    try {
                        platformClientUtil.getBOFactoryService().executeUpdateSql("delete from VCI_SESSIONINFO where TOKEN in (" + WebUtil.toInSql(tokens.toArray(new String[0])) + ")");
                    } catch (PLException e) {
                        if (logger.isErrorEnabled()) {
                            logger.error("删除会话信息", e);
                        }
                    }
                });
            }
            if (logger.isDebugEnabled()) {
                logger.debug("开始执行扫描超时的会话信息完成，删除了{}条数据", invalidSessionList == null ? 0 : invalidSessionList.size());
            }
        }
    }

    /**
     * 创建许可的信息，并存储到缓存中
     *
     * @param sessionInfo session的信息
     * @return 许可信息
     */
    @Override
    public TokenVO createToken(SessionInfo sessionInfo) {
        return createToken(TokenKeyConstant.TOKEN_KEY_PREFIX_IN_REDIS, sessionInfo);
    }

    /**
     * 创建许可的信息，并存储到缓存中
     * @param key token在redis中的key
     * @param sessionInfo session的信息
     * @return 许可信息
     */
    @Override
    public TokenVO createToken(String key, SessionInfo sessionInfo) {
        if(StringUtils.isBlank(sessionInfo.getToken())) {
            String token = Md5.md5(VciBaseUtil.getPk() + "_" + sessionInfo.getUserId());
            sessionInfo.setToken(token);
        }
        if(StringUtils.isBlank(key)){
            key = TokenKeyConstant.TOKEN_KEY_PREFIX_IN_REDIS;
        }
        refreshToken(key, sessionInfo);
        Map<String,Object> claimsMap = new HashMap<>();
        claimsMap.put(TokenKeyConstant.JWT_TOKEN_KEY,sessionInfo.getToken());
        claimsMap.put(TokenKeyConstant.JWT_USER_KEY,sessionInfo.getUserOid());
        claimsMap.put(TokenKeyConstant.JWT_USER_NAME_KEY,sessionInfo.getUserName());
        claimsMap.put(TokenKeyConstant.JWT_USER_CODE_KEY,sessionInfo.getUserId());
        TokenVO tokenVO = new TokenVO();
        tokenVO.setAccessToken(JwtUtils.createToken(claimsMap));
        tokenVO.setExpireTime(TokenKeyConstant.EXPIRATION);
        return tokenVO;
    }

    /**
     * 刷新缓存中的token
     * @param sessionInfo session的信息
     */
    @Override
    public void refreshToken(SessionInfo sessionInfo) {
        refreshToken(TokenKeyConstant.TOKEN_KEY_PREFIX_IN_REDIS, sessionInfo);
    }

    /**
     * 刷新缓存中的token
     * @param key token在redis中的key
     * @param sessionInfo session的信息
     */
    @Override
    public void refreshToken(String key, SessionInfo sessionInfo) {
        if(sessionInfo!=null && StringUtils.isNotBlank(sessionInfo.getToken())){
            if(StringUtils.isBlank(key)){
                key = TokenKeyConstant.TOKEN_KEY_PREFIX_IN_REDIS;
            }
            String redisKey = key + sessionInfo.getToken();
            redisService.setCacheObject(redisKey, sessionInfo, webProperties.getClientSessionAliveMax()!=0?webProperties.getClientSessionAliveMax(): TokenKeyConstant.EXPIRATION, TimeUnit.MINUTES);

            //因为可能需要退出登录，或同一用户只能在线一个，故需要存储，用户和jwtToken的关系
            String tokenKey = CacheNameConstant.cacheKey(CacheNameConstant.USERID_TOKEN_KEY,sessionInfo.getUserId());
            redisService.setCacheObject(tokenKey, redisKey, webProperties.getClientSessionAliveMax()!=0?webProperties.getClientSessionAliveMax(): TokenKeyConstant.EXPIRATION, TimeUnit.MINUTES);
        }
    }

    /**
     * jwt的token改成
     * @param jwtToken jwt的许可
     * @return 在redis里的信息
     */
    private String getSessionTokenKeyInRedis(String jwtToken) {
        if(StringUtils.isBlank(jwtToken)){
            return "";
        }
        String key = TokenKeyConstant.TOKEN_KEY_PREFIX_IN_REDIS;
        if(ControllerUtil.urlDecode(jwtToken).startsWith(key)){
            return ControllerUtil.urlDecode(jwtToken);
        }
        String userToken = JwtUtils.getUserToken(jwtToken);
        return TokenKeyConstant.TOKEN_KEY_PREFIX_IN_REDIS + userToken;
    }

    /**
     * 将token放入平台中
     *
     * @param sessionInfo
     */
    @Override
    public void initInvocationInfo(SessionInfo sessionInfo) {
        InvocationInfo vcii = new InvocationInfo();
        vcii.setToken(sessionInfo.getToken());
        ClientSessionUtility.setInvocationInThread(vcii);
    }
}