package net.weg.maestro.security.loggabledispatcher;

import net.weg.maestro.infrastructure.logging.utils.objectmapper.ObjectMapperHelper;
import net.weg.maestro.wdd3d.configuration.context.ConfigurationContext;
import net.weg.maestro40.core.bean.BeanSession;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.Logger;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.HandlerExecutionChain;
import org.springframework.web.util.ContentCachingRequestWrapper;
import org.springframework.web.util.ContentCachingResponseWrapper;
import org.springframework.web.util.WebUtils;

import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;

public class LoggableDispatcherServlet extends DispatcherServlet implements Filter {

    private static final Logger LOGGER = org.apache.logging.log4j.LogManager.getLogger(LoggableDispatcherServlet.class);

    @Override
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest request1 = request;
        HttpServletResponse response1 = response;

        if (!(request instanceof ContentCachingRequestWrapper)) {
            request1 = new ContentCachingRequestWrapper(request);
        }
        if (!(response instanceof ContentCachingResponseWrapper)) {
            response1 = new ContentCachingResponseWrapper(response);
        }
        HandlerExecutionChain handler = getHandler(request1);
        BeanSession beanSession =  (BeanSession) request1.getSession().getAttribute("scopedTarget.beanSession");
        if(beanSession != null) {
            System.out.println("IN - " + request1.getRequestURI() + "-urs" + ObjectMapperHelper.getInstance().writeValueAsString(((ConfigurationContext) beanSession.getRootState()).getProject().getUserRequirements()));
        }
        try {
            super.doDispatch(request1, response1);
        } finally {
            log(request1, response1, handler);
            updateResponse(response1);
             beanSession =  (BeanSession) request1.getSession().getAttribute("scopedTarget.beanSession");
            if(beanSession != null) {
                System.out.println("OUT - " + request1.getRequestURI() + "-urs" + ObjectMapperHelper.getInstance().writeValueAsString(((ConfigurationContext) beanSession.getRootState()).getProject().getUserRequirements()));
            }
        }
    }

    private void log(HttpServletRequest requestToCache, HttpServletResponse responseToCache, HandlerExecutionChain handler) {
        int status = responseToCache.getStatus();
        if (LOGGER.isDebugEnabled()){
            LOGGER.debug("===========================Loggable Dispacher Servelet begin================================================");
            LOGGER.debug("Status          : {}", responseToCache.getStatus());
            LOGGER.debug("Method          : {}", requestToCache.getMethod());
            LOGGER.debug("URI             : {}", requestToCache.getRequestURI());
            LOGGER.debug("Remote Addr     : {}", requestToCache.getRemoteAddr());
            LOGGER.debug("Handler         : {}", handler.toString());
            LOGGER.debug("Response Payload: {}", getResponsePayload(responseToCache));
            LOGGER.debug("===========================Loggable Dispacher Servelet end==================================================");
        } else if (!(status >= 200 && status < 299)){
            LOGGER.error("===========================Loggable Dispacher Servelet error begin================================================");
            LOGGER.error("Status          : {}", responseToCache.getStatus());
            LOGGER.error("Method          : {}", requestToCache.getMethod());
            LOGGER.error("URI             : {}", requestToCache.getRequestURI());
            LOGGER.error("Remote Addr     : {}", requestToCache.getRemoteAddr());
            LOGGER.error("Handler         : {}", handler.toString());
            LOGGER.error("Response Payload: {}", getResponsePayload(responseToCache));
            LOGGER.error("===========================Loggable Dispacher Servelet error end==================================================");
        }
    }

    private String getResponsePayload(HttpServletResponse response) {
        ContentCachingResponseWrapper wrapper = WebUtils.getNativeResponse(response, ContentCachingResponseWrapper.class);
        String ret = "";
        if (wrapper != null) {
            byte[] buf = wrapper.getContentAsByteArray();
            if (buf.length > 0) {
                int length = Math.min(buf.length, 5120);
                try {
                    ret = new String(buf, 0, length, wrapper.getCharacterEncoding());
                }
                catch (Exception e) {
                    LOGGER.debug("Erro : " + e.getMessage());
                }
            }
        }
        return StringUtils.isNotBlank(ret) ? ret : "[unknown]";
    }

    private void updateResponse(HttpServletResponse response) throws IOException {
        ContentCachingResponseWrapper responseWrapper =
                WebUtils.getNativeResponse(response, ContentCachingResponseWrapper.class);
        responseWrapper.copyBodyToResponse();
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        chain.doFilter(request, response);
    }
}