package registryapi

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

import (
	"bytes"
	"de/nccloud/common"
	"encoding/json"
	"errors"
	"fmt"
	"html"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"strconv"
	"strings"
)

const UserAgent = "apibuilder app.apibuilder.io/nccloud/registry-api/0.0.1/go_1_5_client"
const Version = "0.0.1"
const VersionMajor = 0

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

/**
 * The current state of a single service.
 */
type ServiceState string

const (
	ServiceStateUnavailable ServiceState  = "unavailable" // This service is currently not deployed.
	ServiceStateAvailable                 = "available"   // This service is deployed  and reachable.
	ServiceStateError                     = "error"       // This service is deployed  but not        reachable due to an error.
	ServiceStateUNDEFINED                 = "UNDEFINED"
)

func ServiceStateFromString(value string) ServiceState {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "unavailable":
		return ServiceStateUnavailable
	case "available":
		return ServiceStateAvailable
	case "error":
		return ServiceStateError
	default:
		return ServiceStateUNDEFINED
	}
}

/**
 * Indicates where a service is reachable.
 */
type ServiceType string

const (
	ServiceTypePublic ServiceType  = "public"    // This service is   publicly  reachable.
	ServiceTypeInternal            = "internal"  // This service only reachable internally in the cluster.
	ServiceTypeUNDEFINED           = "UNDEFINED"
)

func ServiceTypeFromString(value string) ServiceType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "public":
		return ServiceTypePublic
	case "internal":
		return ServiceTypeInternal
	default:
		return ServiceTypeUNDEFINED
	}
}

/**
 * A single available service.
 */
type Service struct {
	Name        string       `json:"name"`
	Version     string       `json:"version"`
	State       ServiceState `json:"state"`
	Type        ServiceType  `json:"type"`
	Uri         string       `json:"uri"`
	Title       string       `json:"title,omitempty"`
	Description string       `json:"description,omitempty"`
}

func ServiceFromMap(data interface{}) Service {
	b, err := json.Marshal(data)
	if err == nil {
		return ServiceFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ServiceFromJson(bytes io.Reader) Service {
	var service Service
	json.NewDecoder(bytes).Decode(&service)
	return service
}

/**
 * A service has been undeployed is not reachable anymore.
 */
type ServiceDeletedEvent struct {
	Name      string `json:"name"`
	Timestamp string `json:"timestamp"`
}

func ServiceDeletedEventFromMap(data interface{}) ServiceDeletedEvent {
	b, err := json.Marshal(data)
	if err == nil {
		return ServiceDeletedEventFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ServiceDeletedEventFromJson(bytes io.Reader) ServiceDeletedEvent {
	var serviceDeletedEvent ServiceDeletedEvent
	json.NewDecoder(bytes).Decode(&serviceDeletedEvent)
	return serviceDeletedEvent
}

/**
 * A service has been newly deployed or updated.
 */
type ServiceUpsertedEvent struct {
	Service   Service `json:"service"`
	Timestamp string  `json:"timestamp"`
}

func ServiceUpsertedEventFromMap(data interface{}) ServiceUpsertedEvent {
	b, err := json.Marshal(data)
	if err == nil {
		return ServiceUpsertedEventFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ServiceUpsertedEventFromJson(bytes io.Reader) ServiceUpsertedEvent {
	var serviceUpsertedEvent ServiceUpsertedEvent
	json.NewDecoder(bytes).Decode(&serviceUpsertedEvent)
	return serviceUpsertedEvent
}

type ServiceEvent struct {
	ServiceUpsertedEvent ServiceUpsertedEvent
	ServiceDeletedEvent  ServiceDeletedEvent
	Undefined            string
}

func ServiceEventFromMap(data interface{}) ServiceEvent {
	b, err := json.Marshal(data)
	if err == nil {
		return ServiceEventFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ServiceEventFromJson(bytes io.Reader) ServiceEvent {
	var el map[string]interface{}
	json.NewDecoder(bytes).Decode(&el)
	switch el["type"] {
	case "service_upserted_event":
		return ServiceEvent{ServiceUpsertedEvent: ServiceUpsertedEventFromMap(el)}
	case "service_deleted_event":
		return ServiceEvent{ServiceDeletedEvent: ServiceDeletedEventFromMap(el)}
	default:
		return ServiceEvent{Undefined: el["type"].(string)}
	}
}

type ServicesGetParams struct {
	Offset    int32
	Limit     int32
	SortBy    string
	Direction common.SortDirection
}

type ServicesGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Services   []Service
}

func ServicesGet(client Client, params ServicesGetParams) ServicesGetResponse {

	requestUrl := fmt.Sprintf("%s/", client.BaseUrl)
	urlValues := url.Values{}
	if 0 == params.Offset {
		urlValues.Add("offset", strconv.FormatInt(0, 10))
	} else {
		urlValues.Add("offset", strconv.FormatInt(params.Offset, 10))
	}
	if 0 == params.Limit {
		urlValues.Add("limit", strconv.FormatInt(25, 10))
	} else {
		urlValues.Add("limit", strconv.FormatInt(params.Limit, 10))
	}
	if "" == params.SortBy {
		urlValues.Add("sort_by", "name")
	} else {
		urlValues.Add("sort_by", params.SortBy)
	}
	if "" == params.Direction {
		urlValues.Add("direction", string("asc"))
	} else {
		urlValues.Add("direction", string(params.Direction))
	}

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

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

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

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

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

}

type ServicesGetByNameResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Service    Service
}

func ServicesGetByName(client Client, name string) ServicesGetByNameResponse {

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

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

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

	switch resp.StatusCode {
	case 200:
		return ServicesGetByNameResponse{StatusCode: resp.StatusCode, Response: resp, Service: ServiceFromJson(resp.Body)}

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

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

}

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

func ServicesGetUriByName(client Client, name string) ServicesGetUriByNameResponse {

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

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

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

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

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

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

}

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

	request, err := http.NewRequest(method, urlStr, nil)
	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 client.Username != "" {
		request.SetBasicAuth(client.Username, client.Password)
	}

	return request, nil

}