package com.rf.psychological.filter;

import com.rf.psychological.SoftKey;
import lombok.extern.slf4j.Slf4j;

import javax.servlet.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @author zzf
 * @description:
 * @date 2021/10/29 16:56
 */
@Slf4j
//@Component
public class DogFilter implements Filter {

    /**
     * The <code>doFilter</code> method of the Filter is called by the container
     * each time a request/response pair is passed through the chain due to a
     * client request for a resource at the end of the chain. The FilterChain
     * passed in to this method allows the Filter to pass on the request and
     * response to the next entity in the chain.
     * <p>
     * A typical implementation of this method would follow the following
     * pattern:- <br>
     * 1. Examine the request<br>
     * 2. Optionally wrap the request object with a custom implementation to
     * filter content or headers for input filtering <br>
     * 3. Optionally wrap the response object with a custom implementation to
     * filter content or headers for output filtering <br>
     * 4. a) <strong>Either</strong> invoke the next entity in the chain using
     * the FilterChain object (<code>chain.doFilter()</code>), <br>
     * 4. b) <strong>or</strong> not pass on the request/response pair to the
     * next entity in the filter chain to block the request processing<br>
     * 5. Directly set headers on the response after invocation of the next
     * entity in the filter chain.
     *
     * @param request  The request to process
     * @param response The response associated with the request
     * @param chain    Provides access to the next filter in the chain for this
     *                 filter to pass the request and response to for further
     *                 processing
     * @throws IOException      if an I/O error occurs during this filter's
     *                          processing of the request
     * @throws ServletException if the processing fails for any other reason
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

        HttpServletResponse res = (HttpServletResponse) response;
        int ret;
        SoftKey ytsoftkey = new SoftKey();
        String DevicePath;
        DevicePath = ytsoftkey.FindPort(0);
        boolean flag = false;
        if(ytsoftkey.get_LastError()!=0)
        {
            System.out.println("未找到加密锁,请插入加密锁后，再进行操作。");
            log.error("未找到加密锁,请插入加密锁后，再进行操作。");


        }
        if (ytsoftkey.CheckKeyByFindort_2() == 0)
        {
            System.out.println("使用普通算法一来检查:找到指定的加密锁");
            log.info("使用普通算法一来检查:找到指定的加密锁");
            flag = true;
        }
        else
        {
            log.error("使用普通算法一来检查:未能找到指定的加密锁");
            System.out.println("使用普通算法一来检查:未能找到指定的加密锁");
        }
        ret = ytsoftkey.CheckKeyByEncstring();
        if (ret == 1)
        {
            log.error("你生成加密代码时没有设置该函数");
            System.out.println( "你生成加密代码时没有设置该函数");
        }
        if (ret == 0)
        {
            log.info("使用增强算法一来检查:找到指定的加密锁");
            System.out.println("使用增强算法一来检查:找到指定的加密锁");
            flag = true;
        }
        else
        {
            log.error("使用增强算法一来检查:未能找到指定的加密锁");
            System.out.println("使用增强算法一来检查:未能找到指定的加密锁");
        }
        ret = ytsoftkey.CheckKeyByEncstring_New();
        if (ret == 0)
        {
            log.info("使用增强算法二来检查:找到指定的加密锁");
            System.out.println("使用增强算法二来检查:找到指定的加密锁");
            flag = true;
        }
        else
        {
            if (ret < 0)
            {
                log.error("使用增强算法二来检查:未能找到指定的加密锁");
                System.out.println("使用增强算法二来检查:未能找到指定的加密锁");
            }
            else
            {
                if (ret == 2)
                {
                    log.error("当前锁不支持这个功能。");
                    System.out.println("当前锁不支持这个功能。");
                }
            }
        }
        ret = ytsoftkey.CheckKeyByReadEprom();
        if (ret == 1)
        {
            log.error("加密代码时没有设置该函数");
            System.out.println("加密代码时没有设置该函数");
        }
        if (ret == 0)
        {
            log.info("使用读写储存器来检查:找到指定的加密锁");
            System.out.println("使用读写储存器来检查:找到指定的加密锁");
            flag = true;
        }
        else
        {
            log.error("使用读写储存器来检查:未能找到指定的加密锁");
            System.out.println("使用读写储存器来检查:未能找到指定的加密锁");

        }
        if(flag){
            chain.doFilter(request, response);
        }else {
            res.sendError(403,"使用读写储存器来检查:未能找到指定的加密锁");
        }
    }
}
