import static io.netty.buffer.Unpooled.buffer;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpContent;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpObject;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpResponse;

import java.nio.charset.Charset;

import org.littleshoot.proxy.HttpFilters;
import org.littleshoot.proxy.HttpFiltersAdapter;
import org.littleshoot.proxy.HttpFiltersSourceAdapter;
import org.littleshoot.proxy.HttpProxyServer;
import org.littleshoot.proxy.extras.SelfSignedMitmManager;
import org.littleshoot.proxy.impl.DefaultHttpProxyServer;

/**
 * Simple proxy example -- changes MOB to MOD in responses
 * @author Bruno Candido Volpato da Cunha
 *
 */
public class SimpleProxy {
    public static void main(String[] args) {

        HttpProxyServer server = DefaultHttpProxyServer.bootstrap().withPort(8090).withAllowLocalOnly(false)
                .withListenOnAllAddresses(true).withManInTheMiddle(new SelfSignedMitmManager())
                .withFiltersSource(new HttpFiltersSourceAdapter() {

                    @Override
                    public HttpFilters filterRequest(HttpRequest originalRequest) {
                        System.out.println("Filter " + originalRequest.getUri());

                        HttpFilters filter = new HttpFiltersAdapter(originalRequest) {

                            @Override
                            public HttpResponse requestPre(HttpObject httpObject) {

                                if (!doFilter(originalRequest.getUri())) {
                                    return null;
                                }

                                if (httpObject instanceof HttpRequest) {
                                    HttpRequest httpRequest = (HttpRequest) httpObject;

                                    if (httpRequest.headers().contains("Accept-Encoding")) {
                                        httpRequest.headers().remove("Accept-Encoding");
                                    }
                                }

                                return null;
                            }

                            @Override
                            public HttpObject responsePost(HttpObject httpObject) {

                                if (!doFilter(originalRequest.getUri())) {
                                    return httpObject;
                                }

                                System.out.println("Response post -> " + originalRequest.getUri() + " - "
                                        + httpObject.getClass() + " - " + (httpObject instanceof HttpContent));

                                if (httpObject instanceof HttpContent) {
                                    return proxiedContent((HttpContent) httpObject);
                                }

                                return httpObject;
                            }

                            private HttpContent proxiedContent(HttpContent response) {
                                String text = response.content().toString(Charset.defaultCharset());

                                ProxiedValueVO proxyVO = doProxyValue(originalRequest.getUri(), text);

                                System.out.println("Returning content... Changed? " + proxyVO.isChanged());
                                if (proxyVO.isChanged()) {

                                    ByteBuf contentNew = buffer(1024);
                                    contentNew.writeBytes(proxyVO.getText().getBytes());

                                    System.out.println("[changed] " + proxyVO.getText());

                                    HttpContent newResponse = response.copy();

                                    if (newResponse instanceof DefaultFullHttpResponse) {
                                        DefaultFullHttpResponse fullResponse = (DefaultFullHttpResponse) newResponse;
                                        fullResponse.headers().set("Content-Length", proxyVO.getText().length());
                                    }
                                    newResponse.content().clear().writeBytes(contentNew);
                                    return newResponse;
                                }

                                return response;
                                }
                        };

                        return filter;
                    }

                    @Override
                    public int getMaximumRequestBufferSizeInBytes() {
                        return Integer.MAX_VALUE;
                    };

                    @Override
                    public int getMaximumResponseBufferSizeInBytes() {
                        return Integer.MAX_VALUE;
                    };

                }).start();

    }


    private static ProxiedValueVO doProxyValue(String url, String text) {
        String oldText = text.intern();

        ProxiedValueVO vo = new ProxiedValueVO();
        text = fromTo(text, "MOB", "MOD");

        vo.setChanged(!text.equals(oldText));
        vo.setText(text);

        return vo;
    }

    private static String fromTo(String text, String from, String to) {
        if (text.contains(from)) {
            text = text.replace(from, to);
        }

        return text;
    }

    private static boolean doFilter(String url) {
        if (url.contains("mob.com")) {
            System.out.println("Filter --> " + url);
            return true;
        }

        return false;
    }

}

class ProxiedValueVO {
    private String text;
    private boolean changed;

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    public boolean isChanged() {
        return changed;
    }

    public void setChanged(boolean changed) {
        this.changed = changed;
    }

}