package org.arquillian.cube.toxiproxy;

import feign.gson.GsonDecoder;
import feign.gson.GsonEncoder;

public interface ToxiProxy {

    @feign.RequestLine("GET /proxies")
    Proxy[] getProxies();

    @feign.RequestLine("POST /proxies")
    void createProxy(Proxy proxy);

    @feign.RequestLine("GET /proxies/{proxy}")
    Proxy getProxy(@feign.Param("proxy") String name);

    @feign.RequestLine("POST /proxies/{proxy}")
    Proxy updateProxy(@feign.Param("proxy") String name, Proxy proxy);

    @feign.RequestLine("DELETE /proxies/{proxy}")
    Proxy removeProxy(@feign.Param("proxy") String name);

    @feign.RequestLine("GET /proxies/{proxy}/upstream/toxics")
    Toxic getUpstreamToxic(@feign.Param("proxy") String name);

    @feign.RequestLine("POST /proxies/{proxy}/upstream/toxics/{toxic}")
    void updateUpstreamToxic(@feign.Param("proxy") String name, @feign.Param("toxic") String toxic, ToxicType data);

    @feign.RequestLine("GET /proxies/{proxy}/downstream/toxics")
    Toxic getDownstreamToxic(@feign.Param("proxy") String name);

    @feign.RequestLine("POST /proxies/{proxy}/downstream/toxics/{toxic}")
    void updateDownstreamToxic(@feign.Param("proxy") String name, @feign.Param("toxic") String toxic, ToxicType data);

    @feign.RequestLine("GET /reset")
    void reset();

    public class Proxy {
        private String name;
        private String listen;
        private String upstream;
        private boolean enabled;

        private Toxic upstream_toxics;
        private Toxic downstream_toxics;

        protected Proxy() {}

        public Proxy(String name, String listen, String upstream) {
            this.name = name;
            this.listen = listen;
            this.upstream = upstream;
            this.enabled = true;
        }

        public Proxy addUpstreamToxic(ToxicType type) {
            if(upstream_toxics == null) {
                upstream_toxics = new Toxic();
            }
            if(type instanceof Latency) {
                upstream_toxics.latency = (Latency) type;
            }
            else if(type instanceof SlowClose) {
                upstream_toxics.slow_close = (SlowClose) type;
            }
            else if(type instanceof Timeout) {
                upstream_toxics.timeout = (Timeout) type;
            }

            return this;
        }

        public Proxy addDownstreamToxic(ToxicType type) {
            if(downstream_toxics == null) {
                downstream_toxics = new Toxic();
            }
            if(type instanceof Latency) {
                downstream_toxics.latency = (Latency) type;
            }
            else if(type instanceof SlowClose) {
                downstream_toxics.slow_close = (SlowClose) type;
            }
            else if(type instanceof Timeout) {
                downstream_toxics.timeout = (Timeout) type;
            }

            return this;
        }
    }

    public class Toxic {
        private Latency latency;
        private SlowClose slow_close;
        private Timeout timeout;
    }

    public class ToxicType {
        private boolean enabled;
    }

    public class Latency extends ToxicType {
        private int latency;
        private int jitter;
    }

    public class SlowClose extends ToxicType {
        private int delay;
    }

    public class Timeout extends ToxicType {
        private int timeout;
    }

    public static class Builder {

        public static ToxiProxy create(String url) {
            return feign.Feign.builder()
                        .logger(new feign.Logger.JavaLogger())
                        .logLevel(feign.Logger.Level.FULL)
                        .decoder(new GsonDecoder())
                        .encoder(new GsonEncoder())
                        .target(ToxiProxy.class, url);
        }
    }

    public static class ProxyExpander implements feign.Param.Expander {

        public String expand(Object value) {
            if(!Proxy.class.isInstance(value)) {
                throw new IllegalArgumentException("Object of type " + value.getClass() + " is not of type " + Proxy.class);
            }
            return ((Proxy)value).name;
        }

    }
}