package paintbatchoptimizer

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 1.1.0
 * User agent: apibuilder app.apibuilder.io/paintbatch-com/paint-batch-optimizer/1.1.0/go_1_5_client
 */

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"strconv"
	"strings"
)

const UserAgent = "apibuilder app.apibuilder.io/paintbatch-com/paint-batch-optimizer/1.1.0/go_1_5_client"
const Version = "1.1.0"
const VersionMajor = 1

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

type ClientRequestBody struct {
	contentType string
	bytes       io.Reader
}

/**
 * available paint sheens
 */
type Sheen string

const (
	SheenMatte Sheen  = "Matte"     // matte sheen costs more than gloss
	SheenGloss        = "Gloss"     // gloss sheen costs less than matte
	SheenUNDEFINED    = "UNDEFINED"
)

func SheenFromString(value string) Sheen {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "matte":
		return SheenMatte
	case "gloss":
		return SheenGloss
	default:
		return SheenUNDEFINED
	}
}

/**
 * health of the service
 */
type Status string

const (
	StatusOk Status  = "ok"        // represents the service is live and accepting traffic
	StatusUNDEFINED  = "UNDEFINED"
)

func StatusFromString(value string) Status {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "ok":
		return StatusOk
	default:
		return StatusUNDEFINED
	}
}

/**
 * range of customers preferences to choose from
 */
type Demand struct {
	Paints []Paint `json:"paints"`
}

func DemandFromMap(data interface{}) Demand {
	b, err := json.Marshal(data)
	if err == nil {
		return DemandFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func DemandFromJson(bytes io.Reader) Demand {
	var demand Demand
	json.NewDecoder(bytes).Decode(&demand)
	return demand
}

/**
 * health of the service
 */
type Healthcheck struct {
	Status Status `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
}

/**
 * paint batch optimizer request
 */
type OptimizeRequest struct {
	Colors    int32    `json:"colors"`
	Customers int32    `json:"customers"`
	Demands   []Demand `json:"demands"`
}

func OptimizeRequestFromMap(data interface{}) OptimizeRequest {
	b, err := json.Marshal(data)
	if err == nil {
		return OptimizeRequestFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func OptimizeRequestFromJson(bytes io.Reader) OptimizeRequest {
	var optimizeRequest OptimizeRequest
	json.NewDecoder(bytes).Decode(&optimizeRequest)
	return optimizeRequest
}

/**
 * paint and its sheen
 */
type Paint struct {
	Id    int32 `json:"id"`
	Sheen Sheen `json:"sheen"`
}

func PaintFromMap(data interface{}) Paint {
	b, err := json.Marshal(data)
	if err == nil {
		return PaintFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PaintFromJson(bytes io.Reader) Paint {
	var paint Paint
	json.NewDecoder(bytes).Decode(&paint)
	return paint
}

/**
 * A simple human-readable error
 */
type ReadableError struct {
	Text string `json:"text"`
}

func ReadableErrorFromMap(data interface{}) ReadableError {
	b, err := json.Marshal(data)
	if err == nil {
		return ReadableErrorFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ReadableErrorFromJson(bytes io.Reader) ReadableError {
	var readableError ReadableError
	json.NewDecoder(bytes).Decode(&readableError)
	return readableError
}

type HealthchecksGetHealthcheckResponse struct {
	StatusCode  int
	Response    *http.Response
	Error       error
	Healthcheck Healthcheck
}

func HealthchecksGetHealthcheck(client Client) HealthchecksGetHealthcheckResponse {

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

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

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

	switch resp.StatusCode {
	case 200:
		return HealthchecksGetHealthcheckResponse{StatusCode: resp.StatusCode, Response: resp, Healthcheck: HealthcheckFromJson(resp.Body)}

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

}

type OptimizeRequestsPostOptimizeResponse struct {
	StatusCode    int
	Response      *http.Response
	Error         error
	ReadableError ReadableError
	Value         string
}

func OptimizeRequestsPostOptimize(client Client, optimizeRequest OptimizeRequest) OptimizeRequestsPostOptimizeResponse {

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

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

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

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

	switch resp.StatusCode {
	case 200:
		return OptimizeRequestsPostOptimizeResponse{StatusCode: resp.StatusCode, Response: resp, Value: func() string {
			body, _ := ioutil.ReadAll(resp.Body)
			return string(body)
		}()}

	case 422:
		return OptimizeRequestsPostOptimizeResponse{StatusCode: resp.StatusCode, Response: resp, ReadableError: ReadableErrorFromJson(resp.Body)}

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

}