package reportingapi

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

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

const UserAgent = "apibuilder app.apibuilder.io/nccloud/reporting-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
}

type ClientRequestBody struct {
	contentType string
	bytes       io.Reader
}

/**
 * A type for a topic's schema field.
 */
type ScalarType string

const (
	ScalarTypeBoolean ScalarType  = "boolean"
	ScalarTypeDateIso8601         = "date-iso8601"
	ScalarTypeDateTimeIso8601     = "date-time-iso8601"
	ScalarTypeDecimal             = "decimal"
	ScalarTypeDouble              = "double"
	ScalarTypeInteger             = "integer"
	ScalarTypeLong                = "long"
	ScalarTypeString              = "string"
	ScalarTypeUuid                = "uuid"
	ScalarTypeObject              = "object"            // Note: when a type is set to `object`, the additional fields **must** be defined in the schema.
	ScalarTypeUNDEFINED           = "UNDEFINED"
)

func ScalarTypeFromString(value string) ScalarType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "boolean":
		return ScalarTypeBoolean
	case "date-iso8601":
		return ScalarTypeDateIso8601
	case "date-time-iso8601":
		return ScalarTypeDateTimeIso8601
	case "decimal":
		return ScalarTypeDecimal
	case "double":
		return ScalarTypeDouble
	case "integer":
		return ScalarTypeInteger
	case "long":
		return ScalarTypeLong
	case "string":
		return ScalarTypeString
	case "uuid":
		return ScalarTypeUuid
	case "object":
		return ScalarTypeObject
	default:
		return ScalarTypeUNDEFINED
	}
}

/**
 * Deletes a reporting entity defined by its `tracking_id`.
 */
type DeleteEvent struct {
	TrackingId string       `json:"tracking_id"`
	Audit      common.Audit `json:"audit"`
}

func DeleteEventFromMap(data interface{}) DeleteEvent {
	b, err := json.Marshal(data)
	if err == nil {
		return DeleteEventFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func DeleteEventFromJson(bytes io.Reader) DeleteEvent {
	var deleteEvent DeleteEvent
	json.NewDecoder(bytes).Decode(&deleteEvent)
	return deleteEvent
}

/**
 * Single field of a topic schema. A field can be used for projecting, filtering
 * and sorting in reports.
 */
type Field struct {
	Type        ScalarType       `json:"type"`
	IsArray     string           `json:"is_array"`
	Fields      map[string]Field `json:"fields,omitempty"`
	Label       string           `json:"label,omitempty"`
	Description string           `json:"description,omitempty"`
}

func FieldFromMap(data interface{}) Field {
	b, err := json.Marshal(data)
	if err == nil {
		return FieldFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FieldFromJson(bytes io.Reader) Field {
	var field Field
	json.NewDecoder(bytes).Decode(&field)
	return field
}

/**
 * Defines a condition for values.
 */
type Filter struct {
	Expression string                 `json:"expression,omitempty"`
	Variables  map[string]interface{} `json:"variables,omitempty"`
}

func FilterFromMap(data interface{}) Filter {
	b, err := json.Marshal(data)
	if err == nil {
		return FilterFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func FilterFromJson(bytes io.Reader) Filter {
	var filter Filter
	json.NewDecoder(bytes).Decode(&filter)
	return filter
}

/**
 * A single field of a projection schema.
 */
type ProjectionField struct {
	Label       string                     `json:"label,omitempty"`
	Description string                     `json:"description,omitempty"`
	Source      ProjectionFieldSource      `json:"source,omitempty"`
	Fields      map[string]ProjectionField `json:"fields,omitempty"`
}

func ProjectionFieldFromMap(data interface{}) ProjectionField {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectionFieldFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectionFieldFromJson(bytes io.Reader) ProjectionField {
	var projectionField ProjectionField
	json.NewDecoder(bytes).Decode(&projectionField)
	return projectionField
}

/**
 * Represents the source for a single projection field from a topic's schema.
 */
type ProjectionFieldSource struct {
	Topic  string `json:"topic"`
	Path   string `json:"path"`
	Filter string `json:"filter"`
}

func ProjectionFieldSourceFromMap(data interface{}) ProjectionFieldSource {
	b, err := json.Marshal(data)
	if err == nil {
		return ProjectionFieldSourceFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProjectionFieldSourceFromJson(bytes io.Reader) ProjectionFieldSource {
	var projectionFieldSource ProjectionFieldSource
	json.NewDecoder(bytes).Decode(&projectionFieldSource)
	return projectionFieldSource
}

/**
 * Form for querying and projecting data.
 */
type QueryForm struct {
	View       string                     `json:"view,omitempty"`
	Projection map[string]ProjectionField `json:"projection,omitempty"`
	Variables  map[string]interface{}     `json:"variables"`
	Sort       []common.Sort              `json:"sort,omitempty"`
}

func QueryFormFromMap(data interface{}) QueryForm {
	b, err := json.Marshal(data)
	if err == nil {
		return QueryFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func QueryFormFromJson(bytes io.Reader) QueryForm {
	var queryForm QueryForm
	json.NewDecoder(bytes).Decode(&queryForm)
	return queryForm
}

/**
 * The result of a query, returning data in a projected form.
 */
type QueryResponse struct {
	Page common.PageResponse    `json:"page"`
	Data map[string]interface{} `json:"data"`
}

func QueryResponseFromMap(data interface{}) QueryResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return QueryResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func QueryResponseFromJson(bytes io.Reader) QueryResponse {
	var queryResponse QueryResponse
	json.NewDecoder(bytes).Decode(&queryResponse)
	return queryResponse
}

/**
 * Represents a single topic, which will be consumed by the reporting service.
 */
type Topic struct {
	Name    string             `json:"name"`
	Service common.ServiceInfo `json:"service"`
	Schema  map[string]Field   `json:"schema"`
}

func TopicFromMap(data interface{}) Topic {
	b, err := json.Marshal(data)
	if err == nil {
		return TopicFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TopicFromJson(bytes io.Reader) Topic {
	var topic Topic
	json.NewDecoder(bytes).Decode(&topic)
	return topic
}

type TopicResponse struct {
	Page common.PageResponse `json:"page"`
	Data []Topic             `json:"data"`
}

func TopicResponseFromMap(data interface{}) TopicResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return TopicResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TopicResponseFromJson(bytes io.Reader) TopicResponse {
	var topicResponse TopicResponse
	json.NewDecoder(bytes).Decode(&topicResponse)
	return topicResponse
}

/**
 * Updates one or more data fields.
 */
type UpdateEvent struct {
	TrackingId string                 `json:"tracking_id"`
	Payload    map[string]interface{} `json:"payload"`
	Audit      common.Audit           `json:"audit"`
}

func UpdateEventFromMap(data interface{}) UpdateEvent {
	b, err := json.Marshal(data)
	if err == nil {
		return UpdateEventFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UpdateEventFromJson(bytes io.Reader) UpdateEvent {
	var updateEvent UpdateEvent
	json.NewDecoder(bytes).Decode(&updateEvent)
	return updateEvent
}

/**
 * A stored view containing data from one or more topics.
 */
type View struct {
	Guid       string                     `json:"guid"`
	Name       string                     `json:"name"`
	Projection map[string]ProjectionField `json:"projection"`
	Variables  map[string]ScalarType      `json:"variables"`
}

func ViewFromMap(data interface{}) View {
	b, err := json.Marshal(data)
	if err == nil {
		return ViewFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ViewFromJson(bytes io.Reader) View {
	var view View
	json.NewDecoder(bytes).Decode(&view)
	return view
}

/**
 * Form for creating a new `view`.
 */
type ViewForm struct {
	Name       string                     `json:"name"`
	Projection map[string]ProjectionField `json:"projection"`
	Variables  map[string]ScalarType      `json:"variables"`
}

func ViewFormFromMap(data interface{}) ViewForm {
	b, err := json.Marshal(data)
	if err == nil {
		return ViewFormFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ViewFormFromJson(bytes io.Reader) ViewForm {
	var viewForm ViewForm
	json.NewDecoder(bytes).Decode(&viewForm)
	return viewForm
}

type ViewResponse struct {
	Page common.PageResponse `json:"page"`
	Data []View              `json:"data"`
}

func ViewResponseFromMap(data interface{}) ViewResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return ViewResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ViewResponseFromJson(bytes io.Reader) ViewResponse {
	var viewResponse ViewResponse
	json.NewDecoder(bytes).Decode(&viewResponse)
	return viewResponse
}

type ReportingEvent struct {
	UpdateEvent UpdateEvent
	DeleteEvent DeleteEvent
	Undefined   string
}

func ReportingEventFromMap(data interface{}) ReportingEvent {
	b, err := json.Marshal(data)
	if err == nil {
		return ReportingEventFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ReportingEventFromJson(bytes io.Reader) ReportingEvent {
	var el map[string]interface{}
	json.NewDecoder(bytes).Decode(&el)
	switch el["type"] {
	case "update_event":
		return ReportingEvent{UpdateEvent: UpdateEventFromMap(el)}
	case "delete_event":
		return ReportingEvent{DeleteEvent: DeleteEventFromMap(el)}
	default:
		return ReportingEvent{Undefined: el["type"].(string)}
	}
}

type QueryResponsesPostResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	CommonGenericErrors []common.GenericError
	QueryResponse       QueryResponse
}

func QueryResponsesPost(client Client, queryForm QueryForm) QueryResponsesPostResponse {

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

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

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

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

	switch resp.StatusCode {
	case 200:
		return QueryResponsesPostResponse{StatusCode: resp.StatusCode, Response: resp, QueryResponse: QueryResponseFromJson(resp.Body)}

	case 400:
		return QueryResponsesPostResponse{StatusCode: resp.StatusCode, Response: resp, CommonGenericErrors: func() []common.GenericError {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []common.GenericError
			for _, el := range tmp {
				all = append(all, common.GenericErrorFromMap(el))
			}
			return all
		}()}

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

}

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

type TopicsGetResponse struct {
	StatusCode    int
	Response      *http.Response
	Error         error
	TopicResponse TopicResponse
}

func TopicsGet(client Client, params TopicsGetParams) TopicsGetResponse {

	requestUrl := fmt.Sprintf("%s/topics", 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, ClientRequestBody{})
	if err != nil {
		return TopicsGetResponse{Error: err}
	}

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

	switch resp.StatusCode {
	case 200:
		return TopicsGetResponse{StatusCode: resp.StatusCode, Response: resp, TopicResponse: TopicResponseFromJson(resp.Body)}

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

}

type TopicsGetByGuidResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Topic      Topic
}

func TopicsGetByGuid(client Client, guid string) TopicsGetByGuidResponse {

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

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

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

	switch resp.StatusCode {
	case 200:
		return TopicsGetByGuidResponse{StatusCode: resp.StatusCode, Response: resp, Topic: TopicFromJson(resp.Body)}

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

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

}

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

type ViewsGetResponse struct {
	StatusCode   int
	Response     *http.Response
	Error        error
	ViewResponse ViewResponse
}

func ViewsGet(client Client, params ViewsGetParams) ViewsGetResponse {

	requestUrl := fmt.Sprintf("%s/views", 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, ClientRequestBody{})
	if err != nil {
		return ViewsGetResponse{Error: err}
	}

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

	switch resp.StatusCode {
	case 200:
		return ViewsGetResponse{StatusCode: resp.StatusCode, Response: resp, ViewResponse: ViewResponseFromJson(resp.Body)}

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

}

type ViewsGetByGuidResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	View       View
}

func ViewsGetByGuid(client Client, guid string) ViewsGetByGuidResponse {

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

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

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

	switch resp.StatusCode {
	case 200:
		return ViewsGetByGuidResponse{StatusCode: resp.StatusCode, Response: resp, View: ViewFromJson(resp.Body)}

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

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

}

type ViewsPostResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	CommonGenericErrors []common.GenericError
	View                View
}

func ViewsPost(client Client, viewForm ViewForm) ViewsPostResponse {

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

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

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

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

	switch resp.StatusCode {
	case 201:
		return ViewsPostResponse{StatusCode: resp.StatusCode, Response: resp, View: ViewFromJson(resp.Body)}

	case 400:
		return ViewsPostResponse{StatusCode: resp.StatusCode, Response: resp, CommonGenericErrors: func() []common.GenericError {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []common.GenericError
			for _, el := range tmp {
				all = append(all, common.GenericErrorFromMap(el))
			}
			return all
		}()}

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

}

type ViewsPutByGuidResponse struct {
	StatusCode          int
	Response            *http.Response
	Error               error
	CommonGenericErrors []common.GenericError
	View                View
}

func ViewsPutByGuid(client Client, guid string, viewForm ViewForm) ViewsPutByGuidResponse {

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

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

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

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

	switch resp.StatusCode {
	case 200:
		return ViewsPutByGuidResponse{StatusCode: resp.StatusCode, Response: resp, View: ViewFromJson(resp.Body)}

	case 400:
		return ViewsPutByGuidResponse{StatusCode: resp.StatusCode, Response: resp, CommonGenericErrors: func() []common.GenericError {
			var tmp []interface{}
			json.NewDecoder(resp.Body).Decode(&tmp)
			var all []common.GenericError
			for _, el := range tmp {
				all = append(all, common.GenericErrorFromMap(el))
			}
			return all
		}()}

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

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

}

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

func ViewsDeleteByGuid(client Client, guid string) ViewsDeleteByGuidResponse {

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

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

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

	switch resp.StatusCode {
	case 200:
		return ViewsDeleteByGuidResponse{StatusCode: resp.StatusCode, Response: resp}

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

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

}