package customerapi

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.1-dev
 * User agent: apibuilder app.apibuilder.io/platforminitiative/customer-api/0.0.1-dev/go_1_5_client
 */

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

const BaseUrl = "https://api.apibuilder.io"
const UserAgent = "apibuilder app.apibuilder.io/platforminitiative/customer-api/0.0.1-dev/go_1_5_client"
const Version = "0.0.1-dev"
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
}

/**
 * Customer
 */
type Customer struct {
	FinancialAccountNumber string `json:"financialAccountNumber"`
	CustomerName           string `json:"customerName"`
	BranchNumber           string `json:"branchNumber"`
	Address1               string `json:"address1,omitempty"`
	Address2               string `json:"address2,omitempty"`
	City                   string `json:"city,omitempty"`
	State                  string `json:"state,omitempty"`
	Zip                    string `json:"zip,omitempty"`
}

func CustomerFromMap(data interface{}) Customer {
	b, err := json.Marshal(data)
	if err == nil {
		return CustomerFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CustomerFromJson(bytes io.Reader) Customer {
	var customer Customer
	json.NewDecoder(bytes).Decode(&customer)
	return customer
}

/**
 * customer Creation Form
 */
type CustomerCreateForm struct {
	BranchNumber string `json:"branchNumber"`
	CustomerName string `json:"customerName"`
	Email        string `json:"email"`
	Address1     string `json:"address1"`
	Address2     string `json:"address2,omitempty"`
	City         string `json:"city"`
	State        string `json:"state"`
	Zip          string `json:"zip"`
}

func CustomerCreateFormFromMap(data interface{}) CustomerCreateForm {
	b, err := json.Marshal(data)
	if err == nil {
		return CustomerCreateFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CustomerCreateFormFromJson(bytes io.Reader) CustomerCreateForm {
	var customerCreateForm CustomerCreateForm
	json.NewDecoder(bytes).Decode(&customerCreateForm)
	return customerCreateForm
}

/**
 * Customer Summery
 */
type CustomerSummary struct {
	FinancialAccountNumber string `json:"financialAccountNumber"`
	CustomerName           string `json:"customerName"`
}

func CustomerSummaryFromMap(data interface{}) CustomerSummary {
	b, err := json.Marshal(data)
	if err == nil {
		return CustomerSummaryFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CustomerSummaryFromJson(bytes io.Reader) CustomerSummary {
	var customerSummary CustomerSummary
	json.NewDecoder(bytes).Decode(&customerSummary)
	return customerSummary
}

/**
 * customer Update Form
 */
type CustomerUpdateForm struct {
	FinancialAccountNumber string `json:"financialAccountNumber"`
	CustomerName           string `json:"customerName"`
	Email                  string `json:"email"`
	Address1               string `json:"address1"`
	Address2               string `json:"address2"`
	City                   string `json:"city"`
	State                  string `json:"state"`
	Zip                    string `json:"zip"`
}

func CustomerUpdateFormFromMap(data interface{}) CustomerUpdateForm {
	b, err := json.Marshal(data)
	if err == nil {
		return CustomerUpdateFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func CustomerUpdateFormFromJson(bytes io.Reader) CustomerUpdateForm {
	var customerUpdateForm CustomerUpdateForm
	json.NewDecoder(bytes).Decode(&customerUpdateForm)
	return customerUpdateForm
}

type Error struct {
	Code        string `json:"code"`
	Description string `json:"description"`
}

func ErrorFromMap(data interface{}) Error {
	b, err := json.Marshal(data)
	if err == nil {
		return ErrorFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ErrorFromJson(bytes io.Reader) Error {
	var error_ Error
	json.NewDecoder(bytes).Decode(&error_)
	return error_
}

type CustomersGetCustomersParams struct {
	FinancialAccountNumber string
	Email                  string
	CustomerName           string
}

type CustomersGetCustomersResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Customers  []Customer
	ErrorS     []Error
}

func CustomersGetCustomers(client Client, params CustomersGetCustomersParams) CustomersGetCustomersResponse {

	requestUrl := fmt.Sprintf("%s/customers/customers", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.FinancialAccountNumber {
		urlValues.Add("financialAccountNumber", params.FinancialAccountNumber)
	}
	if "" != params.Email {
		urlValues.Add("email", params.Email)
	}
	if "" != params.CustomerName {
		urlValues.Add("customerName", params.CustomerName)
	}

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

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

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

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

	case 404:
		return CustomersGetCustomersResponse{StatusCode: resp.StatusCode, Response: resp, ErrorS: func() []Error {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Error
			for _, el := range tmp {
				all = append(all, ErrorFromMap(el))
			}
			return all
		}()}

	case 500:
		return CustomersGetCustomersResponse{StatusCode: resp.StatusCode, Response: resp}

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

}

type CustomersGetByCustomerNameResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Customer   Customer
	ErrorS     []Error
}

func CustomersGetByCustomerName(client Client, customerName string) CustomersGetByCustomerNameResponse {

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

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

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

	switch resp.StatusCode {
	case 200:
		return CustomersGetByCustomerNameResponse{StatusCode: resp.StatusCode, Response: resp, Customer: CustomerFromJson(resp.Body)}

	case 404:
		return CustomersGetByCustomerNameResponse{StatusCode: resp.StatusCode, Response: resp, ErrorS: func() []Error {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Error
			for _, el := range tmp {
				all = append(all, ErrorFromMap(el))
			}
			return all
		}()}

	case 500:
		return CustomersGetByCustomerNameResponse{StatusCode: resp.StatusCode, Response: resp}

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

}

type CustomersPostCustomersResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Customer   Customer
}

func CustomersPostCustomers(client Client, customerCreateForm CustomerCreateForm) CustomersPostCustomersResponse {

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

	bodyDocument, err := json.Marshal(customerCreateForm)
	if err != nil {
		return CustomersPostCustomersResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

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

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

	switch resp.StatusCode {
	case 200:
		return CustomersPostCustomersResponse{StatusCode: resp.StatusCode, Response: resp, Customer: CustomerFromJson(resp.Body)}

	case 500:
		return CustomersPostCustomersResponse{StatusCode: resp.StatusCode, Response: resp}

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

}

type CustomersPutByCustomerNameResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Customer   Customer
	ErrorS     []Error
}

func CustomersPutByCustomerName(client Client, customerName string, customerUpdateForm CustomerUpdateForm) CustomersPutByCustomerNameResponse {

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

	bodyDocument, err := json.Marshal(customerUpdateForm)
	if err != nil {
		return CustomersPutByCustomerNameResponse{Error: err}
	}
	body := ClientRequestBody{contentType: "application/json", bytes: bytes.NewReader(bodyDocument)}

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

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

	switch resp.StatusCode {
	case 200:
		return CustomersPutByCustomerNameResponse{StatusCode: resp.StatusCode, Response: resp, Customer: CustomerFromJson(resp.Body)}

	case 404:
		return CustomersPutByCustomerNameResponse{StatusCode: resp.StatusCode, Response: resp, ErrorS: func() []Error {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []Error
			for _, el := range tmp {
				all = append(all, ErrorFromMap(el))
			}
			return all
		}()}

	case 500:
		return CustomersPutByCustomerNameResponse{StatusCode: resp.StatusCode, Response: resp}

	default:
		return CustomersPutByCustomerNameResponse{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

}