package questlogapi

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

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

const BaseUrl = "https://api.questlog.io"
const UserAgent = "apibuilder app.apibuilder.io/poole-solutions/questlog-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
}

type ItemType string

const (
	ItemTypeFood ItemType  = "Food"      // Required to  keep    going
	ItemTypeClothes        = "Clothes"   // Required to  fend    of    nature
	ItemTypeCamp           = "Camp"      // Required for sleep
	ItemTypeUtensils       = "Utensils"  // Required for eating
	ItemTypeGear           = "Gear"      // Required to  perform the   given  activity
	ItemTypeUNDEFINED      = "UNDEFINED"
)

func ItemTypeFromString(value string) ItemType {
	switch strings.TrimSpace(strings.ToLower(value)) {
	case "food":
		return ItemTypeFood
	case "clothes":
		return ItemTypeClothes
	case "camp":
		return ItemTypeCamp
	case "utensils":
		return ItemTypeUtensils
	case "gear":
		return ItemTypeGear
	default:
		return ItemTypeUNDEFINED
	}
}

/**
 * Represents an adventure.
 */
type Adventure struct {
	Guid         string        `json:"guid"`
	Name         string        `json:"name"`
	Description  string        `json:"description,omitempty"`
	Location     string        `json:"location,omitempty"`
	Participants []Participant `json:"participants,omitempty"`
	PackLists    []Item        `json:"pack_lists,omitempty"`
}

func AdventureFromMap(data interface{}) Adventure {
	b, err := json.Marshal(data)
	if err == nil {
		return AdventureFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func AdventureFromJson(bytes io.Reader) Adventure {
	var adventure Adventure
	json.NewDecoder(bytes).Decode(&adventure)
	return adventure
}

/**
 * Represents a validation error from the application.
 */
type Error struct {
	Code    string `json:"code"`
	Message string `json:"message"`
}

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 Guest struct {
	Email string `json:"email,omitempty"`
	Name  string `json:"name,omitempty"`
}

func GuestFromMap(data interface{}) Guest {
	b, err := json.Marshal(data)
	if err == nil {
		return GuestFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func GuestFromJson(bytes io.Reader) Guest {
	var guest Guest
	json.NewDecoder(bytes).Decode(&guest)
	return guest
}

type Item struct {
	Name        string   `json:"name"`
	Size        float64  `json:"size,omitempty"`
	Description string   `json:"description,omitempty"`
	Type        ItemType `json:"type,omitempty"`
}

func ItemFromMap(data interface{}) Item {
	b, err := json.Marshal(data)
	if err == nil {
		return ItemFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ItemFromJson(bytes io.Reader) Item {
	var item Item
	json.NewDecoder(bytes).Decode(&item)
	return item
}

/**
 * Represents a adventure participant and what items they will bring.
 */
type Participant struct {
	Person Person `json:"person"`
	Items  []Item `json:"items,omitempty"`
}

func ParticipantFromMap(data interface{}) Participant {
	b, err := json.Marshal(data)
	if err == nil {
		return ParticipantFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ParticipantFromJson(bytes io.Reader) Participant {
	var participant Participant
	json.NewDecoder(bytes).Decode(&participant)
	return participant
}

type User struct {
	Guid  string `json:"guid"`
	Email string `json:"email,omitempty"`
	Name  string `json:"name,omitempty"`
}

func UserFromMap(data interface{}) User {
	b, err := json.Marshal(data)
	if err == nil {
		return UserFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func UserFromJson(bytes io.Reader) User {
	var user User
	json.NewDecoder(bytes).Decode(&user)
	return user
}

type Person struct {
	Guest     Guest
	User      User
	Undefined string
}

func PersonFromMap(data interface{}) Person {
	b, err := json.Marshal(data)
	if err == nil {
		return PersonFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PersonFromJson(bytes io.Reader) Person {
	var el map[string]interface{}
	json.NewDecoder(bytes).Decode(&el)
	switch el["discriminator"] {
	case "guest":
		return Person{Guest: GuestFromMap(el)}
	case "user":
		return Person{User: UserFromMap(el)}
	default:
		return Person{Undefined: el["discriminator"].(string)}
	}
}

type AdventuresPostParams struct {
	Adventure Adventure
}

type AdventuresPostResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Adventure  Adventure
	ErrorS     []Error
}

func AdventuresPost(client Client, params AdventuresPostParams) AdventuresPostResponse {

	requestUrl := fmt.Sprintf("%s/adventures", client.BaseUrl)
	urlValues := url.Values{}
	adventure, err := json.Marshal(params.Adventure)
	if (err != nil) {
		panic(err)
	}
	urlValues.Add("adventure", string(adventure))
	body := ClientRequestBody{contentType: "application/x-www-form-urlencoded", bytes: strings.NewReader(urlValues.Encode())}

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

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

	switch resp.StatusCode {
	case 201:
		return AdventuresPostResponse{StatusCode: resp.StatusCode, Response: resp, Adventure: AdventureFromJson(resp.Body)}

	case 409:
		return AdventuresPostResponse{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
		}()}

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

}

type AdventuresGetParams struct {
	Guid string
	Name string
}

type AdventuresGetResponse struct {
	StatusCode int
	Response   *http.Response
	Error      error
	Adventures []Adventure
}

func AdventuresGet(client Client, params AdventuresGetParams) AdventuresGetResponse {

	requestUrl := fmt.Sprintf("%s/adventures", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.Guid {
		urlValues.Add("guid", params.Guid)
	}
	if "" != params.Name {
		urlValues.Add("name", params.Name)
	}

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

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

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

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

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

}

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

func AdventuresGetByGuid(client Client, guid string) AdventuresGetByGuidResponse {

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

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

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

	switch resp.StatusCode {
	case 200:
		return AdventuresGetByGuidResponse{StatusCode: resp.StatusCode, Response: resp, Adventure: AdventureFromJson(resp.Body)}

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

}