package com.qianwen.core.http;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Function;
import javax.annotation.Nullable;
import okhttp3.Call;
import okhttp3.Request;
import com.qianwen.core.tool.utils.Exceptions;

/* loaded from: blade-starter-http-9.3.0.0-SNAPSHOT.jar:org/springblade/core/http/Exchange.class */
public class Exchange {
	private BiConsumer<Request, IOException> failedBiConsumer;
	  
	  private final Call call;
	  
	  public Exchange(Call call) {
	    this.failedBiConsumer = ((r, e) -> {
	      
	      });
	    this.call = call;
	  }
	  
	  public Exchange onFailed(BiConsumer<Request, IOException> failConsumer) {
	    this.failedBiConsumer = failConsumer;
	    return this;
	  }
	  
	  public <R> R onResponse(Function<ResponseSpec, R> func) {
	    try (HttpResponse response = new HttpResponse(this.call.execute())) {
	      return func.apply(response);
	    } catch (IOException e) {
	      throw Exceptions.unchecked(e);
	    } 
	  }
	  
	  @Nullable
	  public <R> R onSuccess(Function<ResponseSpec, R> func) {
	    try (HttpResponse response = new HttpResponse(this.call.execute())) {
	      return func.apply(response);
	    } catch (IOException e) {
	      this.failedBiConsumer.accept(this.call.request(), e);
	      return null;
	    } 
	  }
	  
	  @Nullable
	  public <R> R onSuccessful(Function<ResponseSpec, R> func) {
	    try (HttpResponse response = new HttpResponse(this.call.execute())) {
	      if (response.isOk())
	        return func.apply(response); 
	      this.failedBiConsumer.accept(this.call.request(), new IOException(response.toString()));
	    } catch (IOException e) {
	      this.failedBiConsumer.accept(this.call.request(), e);
	    } 
	    return null;
	  }
	  
	  public <R> Optional<R> onSuccessOpt(Function<ResponseSpec, R> func) {
	    return Optional.ofNullable(onSuccess(func));
	  }
	  
	  public <R> Optional<R> onSuccessfulOpt(Function<ResponseSpec, R> func) {
	    return Optional.ofNullable(onSuccessful(func));
	  }
	  
	  public String asString() {
	    return onResponse(ResponseSpec::asString);
	  }
	  
	  public byte[] asBytes() {
	    return onResponse(ResponseSpec::asBytes);
	  }
	  
	  public JsonNode asJsonNode() {
	    return onResponse(ResponseSpec::asJsonNode);
	  }
	  
	  public <T> T asValue(Class<T> valueType) {
	    return onResponse(responseSpec -> responseSpec.asValue(valueType));
	  }
	  
	  public <T> T asValue(TypeReference<T> typeReference) {
	    return onResponse(responseSpec -> responseSpec.asValue(typeReference));
	  }
	  
	  public <T> List<T> asList(Class<T> valueType) {
	    return onResponse(responseSpec -> responseSpec.asList(valueType));
	  }
	  
	  public <K, V> Map<K, V> asMap(Class<?> keyClass, Class<?> valueType) {
	    return onResponse(responseSpec -> responseSpec.asMap(keyClass, valueType));
	  }
	  
	  public <V> Map<String, V> asMap(Class<?> valueType) {
	    return onResponse(responseSpec -> responseSpec.asMap(valueType));
	  }
	  
	  public <T> T asDomValue(Class<T> valueType) {
	    return onResponse(responseSpec -> responseSpec.asDomValue(valueType));
	  }
	  
	  public <T> List<T> asDomList(Class<T> valueType) {
	    return onResponse(responseSpec -> responseSpec.asDomList(valueType));
	  }
	  
	  public File toFile(File file) {
	    return onResponse(responseSpec -> responseSpec.toFile(file));
	  }
	  
	  public Path toFile(Path path) {
	    return onResponse(responseSpec -> responseSpec.toFile(path));
	  }
}