// Code generated from OpenAPI specs by Databricks SDK Generator. DO NOT EDIT.
package com.databricks.sdk.service.{{.Package.Name}};

import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.Map;
import java.time.Duration;
import java.util.Arrays;
import java.util.concurrent.TimeoutException;
import java.util.function.Consumer;
import java.util.function.Function;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.databricks.sdk.core.ApiClient;
import com.databricks.sdk.core.DatabricksException;
import com.databricks.sdk.support.Generated;
import com.databricks.sdk.support.Paginator;
import com.databricks.sdk.support.Wait;

{{range .Package.ImportedEntities}}
import com.databricks.sdk.service.{{.Package.Name}}.{{.PascalName}};{{end}}

{{if .Description}}/**
 {{.Comment " * " 80}}
 */{{end}}
@Generated
public class {{.PascalName}}API {
  private static final Logger LOG = LoggerFactory.getLogger({{.PascalName}}API.class);

  private final {{.PascalName}}Service impl;

  /** Regular-use constructor */
  public {{.PascalName}}API(ApiClient apiClient) {
    impl = new {{.PascalName}}Impl(apiClient);
  }

  /** Constructor for mocks */
  public {{.PascalName}}API({{.PascalName}}Service mock) {
    impl = mock;
  }
  {{range .Waits}}
  public {{.Poll.Response.PascalName}} {{.CamelName}}({{range $i, $x := .Binding}}{{if $i}}, {{end}}{{template "type" .PollField.Entity}} {{.PollField.CamelName}}{{end}})
    throws TimeoutException {
    return {{.CamelName}}({{range .Binding}}{{.PollField.CamelName}}, {{end}}Duration.ofMinutes({{.Timeout}}), null);
  }

  public {{.Poll.Response.PascalName}} {{.CamelName}}({{range .Binding}}{{template "type" .PollField.Entity}} {{.PollField.CamelName}}, {{end}}
    Duration timeout,  Consumer<{{.Poll.Response.PascalName}}> callback) throws TimeoutException {
    long deadline = System.currentTimeMillis() + timeout.toMillis();
    java.util.List<{{.Status.Entity.PascalName}}> targetStates = Arrays.asList({{range $i,$x := .Success}}{{if $i}}, {{end}}{{.Entity.PascalName}}.{{.ConstantName}}{{end}});{{if .Failure}}
    java.util.List<{{.Status.Entity.PascalName}}> failureStates = Arrays.asList({{range $i,$x := .Failure}}{{if $i}}, {{end}}{{.Entity.PascalName}}.{{.ConstantName}}{{end}});{{end}}
    String statusMessage = "polling...";
    int attempt = 1;
    while (System.currentTimeMillis() < deadline) {
        {{.Poll.Response.PascalName}} poll = {{template "java-name" .Poll}}(new {{.Poll.Request.PascalName}}(){{range .Binding}}.set{{.PollField.PascalName}}({{.PollField.CamelName}}){{- end}});
        {{.Status.Entity.PascalName}} status = poll{{range .StatusPath}}.get{{.PascalName}}(){{end}};
        {{if .ComplexMessagePath -}}
        statusMessage = String.format("current status: %s", status);
        if (poll.get{{.MessagePathHead.PascalName}}() != null) {
          statusMessage = poll{{range .MessagePath}}.get{{.PascalName}}(){{end}};
        }
        {{- else if .MessagePath -}}
        statusMessage = poll{{range .MessagePath}}.get{{.PascalName}}(){{end}};
        {{- else -}}
        statusMessage = String.format("current status: %s", status);
        {{- end}}
        if (targetStates.contains(status)) {
            return poll;
        }
        if (callback != null) {
            callback.accept(poll);
        }{{if .Failure -}}
        if (failureStates.contains(status)) {
            String msg = String.format("failed to reach {{range $i, $e := .Success}}{{if $i}} or {{end}}{{$e.ConstantName}}{{end}}, got %s: %s", status, statusMessage);
            throw new IllegalStateException(msg);
        }
        {{end}}
        String prefix = String.format("{{range $i, $b := .Binding}}{{if $i}}, {{end -}}{{.PollField.CamelName}}=%s{{- end}}"{{range .Binding}}, {{.PollField.CamelName}}{{- end}});
        int sleep = attempt;
        if (sleep > 10) {
            // sleep 10s max per attempt
            sleep = 10;
        }
        LOG.info("{}: ({}) {} (sleeping ~{}s)", prefix, status, statusMessage, sleep);
        try {
            Thread.sleep((long) (sleep * 1000L + Math.random() * 1000));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        attempt++;
    }
    throw new TimeoutException(String.format("timed out after %s: %s", timeout, statusMessage));
  }
  {{end}}

	{{range .Methods}}
	{{if and .Request .Request.RequiredFields}}
  public {{template "method-return-type" .}} {{template "java-name" .}}({{range $i, $p := .Request.RequiredFields -}}
    {{if $i}}, {{end}}{{template "type-unboxed" .Entity }} {{.CamelName}}{{if .IsNameReserved}}Value{{end}}
  {{- end}}) {
    {{if or .Response .Wait -}}return {{end}}{{template "java-name" .}}(new {{.Request.PascalName}}(){{range .Request.RequiredFields}}
      .set{{.PascalName}}({{.CamelName}}{{if .IsNameReserved}}Value{{end}}){{end}});
  }
  {{end}}

	{{if .Description}}/**
   {{.Comment "   * " 80}}
   */{{end}}
  public {{template "method-return-type" .}} {{template "java-name" .}}({{if .Request}}{{template "type" .Request}} request{{end}}) {
    {{template "method-call" .}}
  }
  {{end}}
  public {{.PascalName}}Service impl() {
    return impl;
  }
}

{{define "java-name" -}}
{{.CamelName}}{{if .IsNameReserved}}Content{{end}}
{{- end}}

{{define "method-call" -}}
  {{if and .Wait (and (not .IsCrudRead) (not (eq .SnakeName "get_run"))) -}}{{template "method-call-retried" .}}
  {{- else if .Pagination -}}{{template "method-call-paginated" .}}
  {{- else}}{{template "method-call-default" .}}{{end}}
{{- end}}

{{define "method-call-paginated" -}}
  {{- if .Pagination.MultiRequest -}}
    {{- if and .Pagination.Offset (not (eq .Path "/api/2.0/clusters/events")) -}}
    request.set{{.Pagination.Offset.PascalName}}(
    {{- if eq .Pagination.Increment 1 -}}
      1
    {{- else if contains .Path "/scim/v2/" -}}
      1
    {{- else -}}
      0
    {{- end}}L);{{end -}}
    {{if and .Pagination.Limit (contains .Path "/scim/v2/")}}
    if (request.get{{.Pagination.Limit.PascalName}}() == null) {
       request.set{{.Pagination.Limit.PascalName}}(100L);
    }{{end -}}
    return new Paginator<>(request, impl::{{template "java-name" .}}, {{template "type" .Response}}::get{{.Pagination.Results.PascalName}}, response -> {
      {{if eq .Path "/api/2.0/clusters/events" -}}
      return response.getNextPage();
      {{- else if .Pagination.Token -}}
      String token = response.get{{.Pagination.Token.Bind.PascalName}}();
      if (token == null) {
        return null;
      }
      return request.set{{.Pagination.Token.PollField.PascalName}}(token);
      {{- else if eq .Pagination.Increment 1 -}}
      Long page = request.get{{.Pagination.Offset.PascalName}}();
      if (page == null) {
        page = 1L; // redash uses 1-based pagination
      }
      return request.set{{.Pagination.Offset.PascalName}}(page+1L);
      {{- else -}}
      Long offset = request.get{{.Pagination.Offset.PascalName}}();
      if (offset == null) {
        offset = 0L;
      }
      offset += response.get{{.Pagination.Results.PascalName}}().size();
      return request.set{{.Pagination.Offset.PascalName}}(offset);
      {{- end}}
    }){{if .NeedsOffsetDedupe -}}.withDedupe({{.Pagination.Entity.PascalName}}::get{{.IdentifierField.PascalName}}){{end}};
  {{- else -}}
    return impl.{{template "java-name" .}}({{if .Request}}request{{end}}){{with .Pagination.Results}}.get{{.PascalName}}(){{end}};
  {{- end -}}
{{- end}}

{{define "method-call-retried" -}}
    {{if .Response}}{{.Response.PascalName}} response = {{end}}impl.{{template "java-name" .}}(request);
    return new Wait<>((timeout, callback) -> {{.Wait.CamelName}}({{range .Wait.Binding}}{{if .IsResponseBind}}response{{else}}request{{end}}.get{{.Bind.PascalName}}(), {{end}}timeout, callback){{if .Response}}, response{{end}});
{{- end}}

{{define "method-call-default" -}}
  {{if .Response -}}return {{end}}impl.{{template "java-name" .}}({{if .Request}}request{{end}});
{{- end}}

{{define "method-return-type" -}}
  {{if and .Wait (and (not .IsCrudRead) (not (eq .SnakeName "get_run"))) }}Wait<{{.Wait.Poll.Response.PascalName}},{{if .Response}}{{.Response.PascalName}}{{else}}Void{{end}}>
  {{- else if .Response}}{{if .Response.ArrayValue -}}
    Iterable<{{ template "type" .Response.ArrayValue }}>
  {{- else if .Pagination -}}
    Iterable<{{ template "type" .Pagination.Entity }}>
  {{- else -}}
    {{template "type" .Response}}
  {{- end}}{{else}}void{{end}}
{{- end}}