package org.kuali.common.httplib.api.model;

import static com.google.common.base.Charsets.UTF_8;
import static com.google.common.base.Optional.absent;
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.io.ByteSource.wrap;
import static com.google.common.io.Files.asByteSource;
import static org.kuali.common.httplib.api.model.HttpMethod.DELETE;
import static org.kuali.common.httplib.api.model.HttpMethod.POST;
import static org.kuali.common.httplib.api.model.HttpMethod.PUT;
import static org.kuali.common.httplib.api.model.HttpStatusCodeType.SERVER_ERROR;
import static org.kuali.common.jute.base.Precondition.checkMin;
import static org.kuali.common.jute.reflect.Reflection.checkNoNulls;

import java.io.File;
import java.nio.charset.Charset;
import java.util.List;

import com.fasterxml.jackson.annotation.JsonSetter;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Range;
import com.google.common.io.ByteSource;

@JsonDeserialize(builder = HttpOptions.Builder.class)
public final class HttpOptions {

    private final Optional<Long> maxBytes;
    private final Optional<Integer> maxTimeMillis;
    private final Optional<Integer> connectTimeoutMillis;
    private final Optional<Integer> retryCount;
    private final Optional<Integer> retryDelayMillis;
    private final Optional<ByteSource> upload;
    private final Optional<File> outputFile;
    private final boolean cacheResponseInMemory;
    private final boolean printResponseToStdout;
    private final boolean followRedirects;
    private final HttpMethod requestMethod;
    private final Charset charset;
    private final boolean ignoreSecurity;
    private final boolean silent;
    private final ImmutableList<NameValue> data;
    private final Range<Integer> keepTryingRange;
    private final Optional<SecurityContext> security;
    private final ImmutableList<HeaderPair> headers;
    private final Optional<String> contentType;

    private HttpOptions(Builder builder) {
        this.contentType = builder.contentType;
        this.cacheResponseInMemory = builder.cacheResponseInMemory;
        this.printResponseToStdout = builder.printResponseToStdout;
        this.maxTimeMillis = builder.maxTimeMillis;
        this.connectTimeoutMillis = builder.connectTimeoutMillis;
        this.retryCount = builder.retryCount;
        this.retryDelayMillis = builder.retryDelayMillis;
        this.upload = builder.upload;
        this.followRedirects = builder.followRedirects;
        this.requestMethod = builder.requestMethod;
        this.outputFile = builder.outputFile;
        this.charset = builder.charset;
        this.maxBytes = builder.maxBytes;
        this.ignoreSecurity = builder.ignoreSecurity;
        this.silent = builder.silent;
        this.data = ImmutableList.copyOf(builder.data);
        this.headers = ImmutableList.copyOf(builder.headers);
        this.keepTryingRange = builder.keepTryingRange;
        this.security = builder.security;
    }

    public static HttpOptions build() {
        return builder().build();
    }

    public static Builder builder() {
        return new Builder();
    }

    public static class Builder implements org.apache.commons.lang3.builder.Builder<HttpOptions> {

        private Optional<Long> maxBytes = absent();
        private Optional<Integer> maxTimeMillis = absent();
        private Optional<Integer> connectTimeoutMillis = absent();
        private Optional<Integer> retryCount = absent();
        private Optional<Integer> retryDelayMillis = absent();
        private Optional<ByteSource> upload = absent();
        private boolean followRedirects = true;
        private HttpMethod requestMethod = HttpMethod.GET;
        private Optional<File> outputFile = absent();
        private Charset charset = UTF_8;
        private boolean ignoreSecurity = false;
        private boolean silent = true;
        private List<NameValue> data = newArrayList();
        private Range<Integer> keepTryingRange = SERVER_ERROR.getRange();
        private Optional<SecurityContext> security = absent();
        private boolean cacheResponseInMemory = true;
        private boolean printResponseToStdout = false;
        private List<HeaderPair> headers = newArrayList();
        private Optional<String> contentType = absent();

        private static HttpOptions validate(HttpOptions instance) {
            checkNoNulls(instance);
            checkMin(instance.maxBytes, 0, "maxBytes");
            checkMin(instance.maxTimeMillis, 0, "maxTimeMillis");
            checkMin(instance.connectTimeoutMillis, 0, "connectTimeoutMillis");
            checkMin(instance.retryCount, 0, "retryCount");
            checkMin(instance.retryDelayMillis, 0, "retryDelayMillis");
            return instance;
        }

        public Builder withContentType(Optional<String> contentType) {
            this.contentType = contentType;
            return this;
        }

        public Builder withContentType(String contentType) {
            return withContentType(Optional.of(contentType));
        }

        public Builder withHeaders(List<HeaderPair> headers) {
            this.headers = headers;
            return this;
        }

        @JsonSetter
        public Builder withSecurity(Optional<SecurityContext> security) {
            this.security = security;
            return this;
        }

        public Builder withSecurity(SecurityContext security) {
            return withSecurity(Optional.of(security));
        }

        public Builder withCacheResponseInMemory(boolean cacheResponseInMemory) {
            this.cacheResponseInMemory = cacheResponseInMemory;
            return this;
        }

        public Builder cacheResponseInMemory() {
            return withCacheResponseInMemory(true);
        }

        public Builder withPrintResponseToStdout(boolean printResponseToStdout) {
            this.printResponseToStdout = printResponseToStdout;
            return this;
        }

        public Builder printResponseToStdout() {
            return withPrintResponseToStdout(true);
        }

        @JsonSetter
        public Builder withOutputFile(Optional<File> outputFile) {
            this.outputFile = outputFile;
            return this;
        }

        public Builder withOutputFile(File outputFile) {
            return withOutputFile(Optional.of(outputFile));
        }

        public Builder withKeepTryingRange(Range<Integer> keepTryingRange) {
            this.keepTryingRange = keepTryingRange;
            return this;
        }

        public Builder withData(List<NameValue> data) {
            this.data = data;
            return this;
        }

        public Builder withSilent(boolean silent) {
            this.silent = silent;
            return this;
        }

        public Builder ignoreSecurity() {
            return withIgnoreSecurity(true);
        }

        public Builder withIgnoreSecurity(boolean ignoreSecurity) {
            this.ignoreSecurity = ignoreSecurity;
            return this;
        }

        @JsonSetter
        public Builder withMaxBytes(Optional<Long> maxBytes) {
            this.maxBytes = maxBytes;
            return this;
        }

        public Builder withMaxBytes(long maxBytes) {
            return withMaxBytes(Optional.of(maxBytes));
        }

        public Builder withCharset(Charset charset) {
            this.charset = charset;
            return this;
        }

        public Builder withEncoding(String encoding) {
            return withCharset(Charset.forName(encoding));
        }

        public Builder post() {
            return withRequestMethod(POST);
        }

        public Builder delete() {
            return withRequestMethod(DELETE);
        }

        public Builder put() {
            return withRequestMethod(PUT);
        }

        public Builder withRequestMethod(HttpMethod requestMethod) {
            this.requestMethod = requestMethod;
            return this;
        }

        @JsonSetter
        public Builder withRetryCount(Optional<Integer> retries) {
            this.retryCount = retries;
            return this;
        }

        public Builder withRetryCount(int retries) {
            return withRetryCount(Optional.of(retries));
        }

        public Builder withFollowRedirects(boolean followRedirects) {
            this.followRedirects = followRedirects;
            return this;
        }

        public Builder followRedirects() {
            return withFollowRedirects(true);
        }

        @JsonSetter
        public Builder withConnectTimeoutMillis(Optional<Integer> connectTimeoutMillis) {
            this.connectTimeoutMillis = connectTimeoutMillis;
            return this;
        }

        public Builder withConnectTimeoutMillis(int connectTimeoutMillis) {
            return withConnectTimeoutMillis(Optional.of(connectTimeoutMillis));
        }

        @JsonSetter
        public Builder withMaxTimeMillis(Optional<Integer> maxTimeMillis) {
            this.maxTimeMillis = maxTimeMillis;
            return this;
        }

        public Builder withMaxTimeMillis(int maxTimeMillis) {
            return withMaxTimeMillis(Optional.of(maxTimeMillis));
        }

        @JsonSetter
        public Builder withRetryDelayMillis(Optional<Integer> retryDelayMillis) {
            this.retryDelayMillis = retryDelayMillis;
            return this;
        }

        public Builder withRetryDelayMillis(int retryDelayMillis) {
            return withRetryDelayMillis(Optional.of(retryDelayMillis));
        }

        @JsonSetter
        public Builder withUpload(Optional<ByteSource> upload) {
            this.upload = upload;
            return this;
        }

        public Builder withUpload(ByteSource upload) {
            return withUpload(Optional.of(upload));
        }

        public Builder upload(File file) {
            return withUpload(asByteSource(file));
        }

        public Builder upload(String content, Charset charset) {
            return withUpload(wrap(content.getBytes(charset)));
        }

        @Override
        public HttpOptions build() {
            return validate(new HttpOptions(this));
        }

    }

    public Optional<Integer> getMaxTimeMillis() {
        return maxTimeMillis;
    }

    public Optional<Integer> getConnectTimeoutMillis() {
        return connectTimeoutMillis;
    }

    public Optional<Integer> getRetries() {
        return retryCount;
    }

    public Optional<Integer> getRetryDelayMillis() {
        return retryDelayMillis;
    }

    public Optional<ByteSource> getUpload() {
        return upload;
    }

    public boolean isFollowRedirects() {
        return followRedirects;
    }

    public HttpMethod getMethod() {
        return requestMethod;
    }

    public Optional<Integer> getRetryCount() {
        return retryCount;
    }

    public HttpMethod getRequestMethod() {
        return requestMethod;
    }

    public Optional<Long> getMaxBytes() {
        return maxBytes;
    }

    public boolean isIgnoreSecurity() {
        return ignoreSecurity;
    }

    public boolean isSilent() {
        return silent;
    }

    public List<NameValue> getData() {
        return data;
    }

    public Charset getCharset() {
        return charset;
    }

    public Range<Integer> getKeepTryingRange() {
        return keepTryingRange;
    }

    public Optional<File> getOutputFile() {
        return outputFile;
    }

    public boolean isCacheResponseInMemory() {
        return cacheResponseInMemory;
    }

    public Optional<SecurityContext> getSecurity() {
        return security;
    }

    public boolean isPrintResponseToStdout() {
        return printResponseToStdout;
    }

    public List<HeaderPair> getHeaders() {
        return headers;
    }

    public Optional<String> getContentType() {
        return contentType;
    }

}