/**
 * web配置
 *
 * @author zhoukun
 */
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                //授权的访问源
                .allowedOrigins("*")
                //允许的请求动词
                .allowedMethods("POST, GET, OPTIONS, DELETE")
                //预检授权的有效期，单位：秒
                .maxAge(3600)
                //额外允许访问的响应头
                .allowedHeaders("x-requested-with")
                //是否允许携带
                .allowCredentials(true);
    }
}

/**
 * 登入拦截
 *
 * @author zhoukun
 */
@Component
public class LoginInterceptor implements HandlerInterceptor {
    private static final String OK = "ok";

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = request.getHeader("token");
        if (StringUtils.isEmpty(token)) {
            token = request.getParameter("token");
        }
        if (StringUtils.isEmpty(token)) {
            Cookie[] cookies = request.getCookies();
            if (cookies != null && cookies.length > 0) {
                for (Cookie cookie : cookies) {
                    if (cookie.getName().equals("token")) {
                        token = cookie.getValue();
                    }
                }
            }
        }
        String originUrl = request.getRequestURL().toString();
        if (StringUtils.isEmpty(token)) {
            response.sendRedirect("http://127.0.0.1:2080?originUrl=" + originUrl);
            return false;
        }
//        if (!StringUtils.isEmpty(token)) {
//            Cookie cookie = new Cookie("token", token);
//            cookie.setDomain("zk.com");
//            response.addCookie(cookie);
//        }
        Map<String, String> map = new HashMap<>();
        map.put("token", token);
        String result = httpClientGet(map);
        if (OK.equalsIgnoreCase(result)) {
            return true;
        } else {
            response.sendRedirect("http://127.0.0.1:2080?originUrl=" + originUrl);
            return false;
        }
    }


    public static String httpClientGet(Map<String, String> map) throws URISyntaxException, IOException {
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();

        List<NameValuePair> params = new ArrayList<>();
        map.forEach((k, v) ->
                params.add(new BasicNameValuePair(k, v))
        );

        URI uri = new URIBuilder().setScheme("http").setHost("localhost")
                .setPort(2080).setPath("/auth/token")
                .setParameters(params).build();

        HttpGet get = new HttpGet(uri);
        CloseableHttpResponse response = httpClient.execute(get);

        HttpEntity responseEntity = response.getEntity();
        System.out.println("响应状态为:" + response.getStatusLine());
        String result = EntityUtils.toString(responseEntity);

        httpClient.close();
        response.close();
        return result;

    }

}

/**
 * 登入页面
 *
 * @author zhoukun
 */
@Controller
public class LoginController {

    @Autowired
    private UserService userService;

    @GetMapping("/")
    public String form(HttpServletRequest request, HttpServletResponse response) {
        String originUrl = request.getParameter("originUrl");
        request.getSession().setAttribute("originUrl", originUrl);
        return "login";
    }

    @GetMapping("/login")
    @ResponseBody
    public String login(HttpServletRequest request, HttpServletResponse response,
                        @RequestParam("username") String username, @RequestParam("password") String password) throws IOException {
        if (StringUtils.isEmpty(username)) {
            return "username not null";
        }
        if (StringUtils.isEmpty(password)) {
            return "password not null";
        }

        UserDo userDo = userService.verifyUser(username, password);
        if (userDo == null) {
            return "密码或者账号错误!";
        }
        Map<String, String> claims = new HashMap<>();
        claims.put("id", String.valueOf(userDo.getId()));
        claims.put("username", userDo.getUserName());
        LocalDateTime exprieLocalDateTime = LocalDateTime.now().plusMinutes(10L);
        ZonedDateTime zonedDateTime = exprieLocalDateTime.atZone(ZoneId.systemDefault());
        String token = JwtUtil.generateToken(claims, Date.from(zonedDateTime.toInstant()));
        Cookie cookie = new Cookie("token", token);
        response.addCookie(cookie);
        response.setHeader("token", token);
        String originUrl = (String) request.getSession().getAttribute("originUrl");
        response.sendRedirect(originUrl + "?token=" + token);
        return token;
    }
}

/**
 * 认证Token
 *
 * @author zhoukun
 */
@RestController
@RequestMapping("auth")
public class AuthTokenController {
    public static final String OK = "OK";
    public static final String FAIL = "FAIL";


    @GetMapping("token")
    public String authToken(HttpServletRequest request, HttpServletResponse response) {
        String token = request.getParameter("token");
        try {
            Map<String, String> map = JwtUtil.verifyToken(token);
            return OK;
        } catch (Exception e) {
            e.printStackTrace();
            return FAIL;
        }
    }


}

/**
 * jwt TOKEN 生成 解析
 *
 * @author zhoukun
 */
@Slf4j
public class JwtUtil {

    private JwtUtil() {

    }

    /**
     * 加密Key
     */
    public static final String SECRET = "c61070db-450b-419e-8ff9-e45fae4f6e3c";
    /**
     * 发行人
     */
    private static String ISSUER = "JackKun";


    /**
     * 生成Token
     *
     * @param claims     主体
     * @param expireDate 过期时间
     * @return
     */
    public static String generateToken(Map<String, String> claims, Date expireDate) {
        try {
            //申明加密算法
            Algorithm algorithm = Algorithm.HMAC256(SECRET);

            //创建JWT
            JWTCreator.Builder builder = JWT.create()
                    .withIssuer(ISSUER)
                    .withExpiresAt(expireDate);

            //设置主体参数
            claims.forEach((k, v) -> {
                builder.withClaim(k, v);
            });

            //返回加密签名 token
            return builder.sign(algorithm);
        } catch (IllegalArgumentException e) {
            log.error("生成Token 非法参数异常! errMsg:{}", e);
            throw new RuntimeException(e);

        } catch (JWTCreationException e) {
            log.error("生成Token 创建JWT异常! errMsg:{}", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 验证Token
     *
     * @return
     */
    public static Map<String, String> verifyToken(String token) {
        //申明加密算法
        Algorithm algorithm = Algorithm.HMAC256(SECRET);

        JWTVerifier verifier = JWT.require(algorithm)
                .withIssuer(ISSUER)
                .build();
        DecodedJWT jwt = verifier.verify(token);

        Map<String, String> resultMap = new HashMap<>();
        Map<String, Claim> claimMap = jwt.getClaims();
        claimMap.forEach((k, v) -> resultMap.put(k, v.asString()));
        return resultMap;
    }
}