/*

* Copyright 2013 Netflix, Inc.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package feign;

import java.io.IOException;

import java.lang.reflect.Type;

import java.net.URI;

import javax.inject.Inject;

import javax.inject.Provider;

import feign.Request.Options;

import feign.codec.Decoder;

import feign.codec.ErrorDecoder;

import static feign.FeignException.errorExecuting;

import static feign.FeignException.errorReading;

import static feign.Util.LOCATION;

import static feign.Util.checkNotNull;

import static feign.Util.firstOrNull;

final class MethodHandler {

/**

* Those using guava will implement as {@code Function<Object[], RequestTemplate>}.

*/

static interface BuildTemplateFromArgs {

public RequestTemplate apply(Object[] argv);

}

static class Factory {

private final Client client;

private final Provider<Retryer> retryer;

private final Wire wire;

@Inject Factory(Client client, Provider<Retryer> retryer, Wire wire) {

this.client = checkNotNull(client, "client");

this.retryer = checkNotNull(retryer, "retryer");

this.wire = checkNotNull(wire, "wire");

}

public MethodHandler create(Target<?> target, MethodMetadata md,

BuildTemplateFromArgs buildTemplateFromArgs, Options options, Decoder decoder, ErrorDecoder errorDecoder) {

return new MethodHandler(target, client, retryer, wire, md, buildTemplateFromArgs, options, decoder, errorDecoder);

}

}

private final MethodMetadata metadata;

private final Target<?> target;

private final Client client;

private final Provider<Retryer> retryer;

private final Wire wire;

private final BuildTemplateFromArgs buildTemplateFromArgs;

private final Options options;

private final Decoder decoder;

private final ErrorDecoder errorDecoder;

// cannot inject wildcards in dagger

@SuppressWarnings("rawtypes")

private MethodHandler(Target target, Client client, Provider<Retryer> retryer, Wire wire, MethodMetadata metadata,

BuildTemplateFromArgs buildTemplateFromArgs, Options options, Decoder decoder, ErrorDecoder errorDecoder) {

this.target = checkNotNull(target, "target");

this.client = checkNotNull(client, "client for %s", target);

this.retryer = checkNotNull(retryer, "retryer for %s", target);

this.wire = checkNotNull(wire, "wire for %s", target);

this.metadata = checkNotNull(metadata, "metadata for %s", target);

this.buildTemplateFromArgs = checkNotNull(buildTemplateFromArgs, "metadata for %s", target);

this.options = checkNotNull(options, "options for %s", target);

this.decoder = checkNotNull(decoder, "decoder for %s", target);

this.errorDecoder = checkNotNull(errorDecoder, "errorDecoder for %s", target);

}

public Object invoke(Object[] argv) throws Throwable {

RequestTemplate template = buildTemplateFromArgs.apply(argv);

Retryer retryer = this.retryer.get();

while (true) {

try {

return executeAndDecode(metadata.configKey(), template, metadata.returnType());

} catch (RetryableException e) {

retryer.continueOrPropagate(e);

continue;

}

}

}

public Object executeAndDecode(String configKey, RequestTemplate template, Type returnType)

throws Throwable {

// create the request from a mutable copy of the input template.

Request request = target.apply(new RequestTemplate(template));

wire.wireRequest(target, request);

Response response = execute(request);

try {

response = wire.wireAndRebufferResponse(target, response);

if (response.status() >= 200 && response.status() < 300) {

if (returnType.equals(Response.class)) {

return response;

} else if (returnType == URI.class && response.body() == null) {

String location = firstOrNull(response.headers(), LOCATION);

if (location != null)

return URI.create(location);

} else if (returnType == void.class) {

return null;

}

return decoder.decode(configKey, response, returnType);

} else {

return errorDecoder.decode(configKey, response, returnType);

}

} catch (Throwable e) {

ensureBodyClosed(response);

if (IOException.class.isInstance(e))

throw errorReading(request, response, IOException.class.cast(e));

throw e;

}

}

private void ensureBodyClosed(Response response) {

if (response.body() != null) {

try {

response.body().close();

} catch (IOException ignored) { // NOPMD

}

}

}

private Response execute(Request request) {

try {

return client.execute(request, options);

} catch (IOException e) {

throw errorExecuting(request, e);

}

}

}