package bmlgentestapplication

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.2
 * User agent: apibuilder app.apibuilder.io/bml/bml-gen-test-application/0.0.2/go_1_5_client
 */

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"html"
	"io"
	"net/http"
	"net/url"
	"org/bml/validation"
	"strconv"
	"strings"
)

const UserAgent = "apibuilder app.apibuilder.io/bml/bml-gen-test-application/0.0.2/go_1_5_client"
const Version = "0.0.2"
const VersionMajor = 0

type Client struct {
	HttpClient *http.Client
	Username   string
	Password   string
	BaseUrl    string
	Headers    http.Header
}

type ClientRequestBody struct {
	contentType string
	bytes       io.Reader
}

/**
 * Test Enumeration provides a useful test for enumeration based code generation.
 */
type TestEnumeration string

const (
	TestEnumerationFoo TestEnumeration  = "foo"       // A foo enumeration entry.
	TestEnumerationBar                  = "bar"       // A bar enumeration entry.
	TestEnumerationUNDEFINED            = "UNDEFINED"
)

func TestEnumerationFromString(value string) TestEnumeration {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "foo":
		return TestEnumerationFoo
	case "bar":
		return TestEnumerationBar
	default:
		return TestEnumerationUNDEFINED
	}
}

/**
 * This is the top level in the system. It represents a specific client.
 */
type Account struct {
	Id         string `json:"id"`
	AwsAccount string `json:"awsAccount"`
	Name       string `json:"name"`
	Enabled    string `json:"enabled"`
}

func AccountFromMap(data interface{}) Account {
	b, err := json.Marshal(data)
	if err == nil {
		return AccountFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func AccountFromJson(bytes io.Reader) Account {
	var account Account
	json.NewDecoder(bytes).Decode(&account)
	return account
}

/**
 * A form used for creating an Account resource.
 */
type AccountForm struct {
	Name    string `json:"name"`
	Enabled string `json:"enabled"`
}

func AccountFormFromMap(data interface{}) AccountForm {
	b, err := json.Marshal(data)
	if err == nil {
		return AccountFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func AccountFormFromJson(bytes io.Reader) AccountForm {
	var accountForm AccountForm
	json.NewDecoder(bytes).Decode(&accountForm)
	return accountForm
}

/**
 * A model client for testing generation.
 */
type Client struct {
	Accounts []Account `json:"accounts"`
}

func ClientFromMap(data interface{}) Client {
	b, err := json.Marshal(data)
	if err == nil {
		return ClientFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ClientFromJson(bytes io.Reader) Client {
	var client Client
	json.NewDecoder(bytes).Decode(&client)
	return client
}

/**
 * A response model for the standard health check resource.
 */
type Healthcheck struct {
	Status string `json:"status"`
}

func HealthcheckFromMap(data interface{}) Healthcheck {
	b, err := json.Marshal(data)
	if err == nil {
		return HealthcheckFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func HealthcheckFromJson(bytes io.Reader) Healthcheck {
	var healthcheck Healthcheck
	json.NewDecoder(bytes).Decode(&healthcheck)
	return healthcheck
}

type AccountsPostParams struct {
	Test        string
	TestDefault string
}

type AccountsPostResponse struct {
	StatusCode                        int
	Response                          *http.Response
	Error                             error
	Account                           Account
	ValidationFieldValidationResponse validation.FieldValidationResponse
}

func AccountsPost(client Client, params AccountsPostParams, accountForm AccountForm) AccountsPostResponse {

	requestUrl := fmt.Sprintf("%s/accounts", client.BaseUrl)

	bodyDocument, err := json.Marshal(accountForm)
	if err != nil {
		return AccountsPostResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}
	urlValues := url.Values{}
	if "" != params.Test {
		urlValues.Add("test", params.Test)
	}
	if "" == params.TestDefault {
		urlValues.Add("testDefault", "false")
	} else {
		urlValues.Add("testDefault", params.TestDefault)
	}

	encodedValues := urlValues.Encode()
	if encodedValues != "" {
		requestUrl += "?" + encodedValues
	}

	request, err := buildRequest(client, "POST", requestUrl, body)
	if err != nil {
		return AccountsPostResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return AccountsPostResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 201:
		return AccountsPostResponse{StatusCode: resp.StatusCode, Response: resp, Account: AccountFromJson(resp.Body)}

	case 409:
		return AccountsPostResponse{StatusCode: resp.StatusCode, Response: resp}

	case 400:
		return AccountsPostResponse{StatusCode: resp.StatusCode, Response: resp, ValidationFieldValidationResponse: validation.FieldValidationResponseFromJson(resp.Body)}

	case 401:
		return AccountsPostResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return AccountsPostResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type AccountsGetByIdResponse struct {
	StatusCode                        int
	Response                          *http.Response
	Error                             error
	Account                           Account
	ValidationFieldValidationResponse validation.FieldValidationResponse
}

func AccountsGetById(client Client, id string) AccountsGetByIdResponse {

	requestUrl := fmt.Sprintf("%s/accounts/%s", client.BaseUrl, html.EscapeString(id))

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return AccountsGetByIdResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return AccountsGetByIdResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return AccountsGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Account: AccountFromJson(resp.Body)}

	case 400:
		return AccountsGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, ValidationFieldValidationResponse: validation.FieldValidationResponseFromJson(resp.Body)}

	case 401:
		return AccountsGetByIdResponse{StatusCode: resp.StatusCode, Response: resp}

	case 404:
		return AccountsGetByIdResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return AccountsGetByIdResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type AccountsGetFooByIdParams struct {
	Name  string
	Page  int32
	Count int32
}

type AccountsGetFooByIdResponse struct {
	StatusCode                        int
	Response                          *http.Response
	Error                             error
	Accounts                          []Account
	ValidationFieldValidationResponse validation.FieldValidationResponse
}

func AccountsGetFooById(client Client, id string, params AccountsGetFooByIdParams) AccountsGetFooByIdResponse {

	requestUrl := fmt.Sprintf("%s/accounts/%s/foo", client.BaseUrl, html.EscapeString(id))
	urlValues := url.Values{}
	if "" != params.Name {
		urlValues.Add("name", params.Name)
	}
	if 0 == params.Page {
		urlValues.Add("page", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("page", strconv.FormatInt(params.Page, 10))
	}
	if 0 == params.Count {
		urlValues.Add("count", strconv.FormatInt(100, 10))
	} else {
		urlValues.Add("count", strconv.FormatInt(params.Count, 10))
	}

	encodedValues := urlValues.Encode()
	if encodedValues != "" {
		requestUrl += "?" + encodedValues
	}

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return AccountsGetFooByIdResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return AccountsGetFooByIdResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return AccountsGetFooByIdResponse{StatusCode: resp.StatusCode, Response: resp, Accounts: func() []Account {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Account
			for _, el := range tmp {
				all = append(all, AccountFromMap(el))
			}
			return all
		}()}

	case 400:
		return AccountsGetFooByIdResponse{StatusCode: resp.StatusCode, Response: resp, ValidationFieldValidationResponse: validation.FieldValidationResponseFromJson(resp.Body)}

	case 401:
		return AccountsGetFooByIdResponse{StatusCode: resp.StatusCode, Response: resp}

	case 404:
		return AccountsGetFooByIdResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return AccountsGetFooByIdResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type AccountsGetParams struct {
	Name  string
	Page  int32
	Count int32
}

type AccountsGetResponse struct {
	StatusCode                        int
	Response                          *http.Response
	Error                             error
	Accounts                          []Account
	ValidationFieldValidationResponse validation.FieldValidationResponse
}

func AccountsGet(client Client, params AccountsGetParams) AccountsGetResponse {

	requestUrl := fmt.Sprintf("%s/accounts", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Name {
		urlValues.Add("name", params.Name)
	}
	if 0 == params.Page {
		urlValues.Add("page", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("page", strconv.FormatInt(params.Page, 10))
	}
	if 0 == params.Count {
		urlValues.Add("count", strconv.FormatInt(100, 10))
	} else {
		urlValues.Add("count", strconv.FormatInt(params.Count, 10))
	}

	encodedValues := urlValues.Encode()
	if encodedValues != "" {
		requestUrl += "?" + encodedValues
	}

	request, err := buildRequest(client, "GET", requestUrl, ClientRequestBody{})
	if err != nil {
		return AccountsGetResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return AccountsGetResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return AccountsGetResponse{StatusCode: resp.StatusCode, Response: resp, Accounts: func() []Account {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Account
			for _, el := range tmp {
				all = append(all, AccountFromMap(el))
			}
			return all
		}()}

	case 400:
		return AccountsGetResponse{StatusCode: resp.StatusCode, Response: resp, ValidationFieldValidationResponse: validation.FieldValidationResponseFromJson(resp.Body)}

	case 401:
		return AccountsGetResponse{StatusCode: resp.StatusCode, Response: resp}

	case 404:
		return AccountsGetResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return AccountsGetResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

type AccountsDeleteByIdResponse struct {
	StatusCode                        int
	Response                          *http.Response
	Error                             error
	Account                           Account
	ValidationFieldValidationResponse validation.FieldValidationResponse
}

func AccountsDeleteById(client Client, id string) AccountsDeleteByIdResponse {

	requestUrl := fmt.Sprintf("%s/accounts/%s", client.BaseUrl, html.EscapeString(id))

	request, err := buildRequest(client, "DELETE", requestUrl, ClientRequestBody{})
	if err != nil {
		return AccountsDeleteByIdResponse{Error: err}
	}

	resp, err := client.HttpClient.Do(request)
	if err != nil {
		return AccountsDeleteByIdResponse{Error: err}
	}
	defer resp.Body.Close()

	switch resp.StatusCode {
	case 200:
		return AccountsDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, Account: AccountFromJson(resp.Body)}

	case 400:
		return AccountsDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, ValidationFieldValidationResponse: validation.FieldValidationResponseFromJson(resp.Body)}

	case 401:
		return AccountsDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp}

	case 404:
		return AccountsDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return AccountsDeleteByIdResponse{StatusCode: resp.StatusCode, Response: resp, Error: errors.New(resp.Status)}
	}

}

func buildRequest(client Client, method, urlStr string, body ClientRequestBody) (*http.Request, error) {

	request, err := http.NewRequest(method, urlStr, body.bytes)
	if err != nil {
		return nil, err
	}

	request.Header.Add("User-Agent",             UserAgent)
	request.Header.Add("X-Apidoc-Version",       Version)
	request.Header.Add("X-Apidoc-Version-Major", strconv.Itoa(VersionMajor))

	if client.Headers != nil {
		for key, values := range client.Headers {
			for _, value := range values {
				request.Header.Add(key, value)
			}
		}
	}

	if body.contentType != "" {
		request.Header.Add("Content-Type", body.contentType)
	}

	if client.Username != "" {
		request.SetBasicAuth(client.Username, client.Password)
	}

	return request, nil

}