package foursquare

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.1-dev
 * User agent: apibuilder app.apibuilder.io/natalia/foursquare/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.foursquare.com/v2"
const UserAgent = "apibuilder app.apibuilder.io/natalia/foursquare/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
}

/**
 * Photo of venues
 */
type Photo struct {
	Prefix string `json:"prefix"`
	Suffix string `json:"suffix"`
	Width  int32  `json:"width"`
	Height int32  `json:"height"`
}

func PhotoFromMap(data interface{}) Photo {
	b, err := json.Marshal(data)
	if err == nil {
		return PhotoFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PhotoFromJson(bytes io.Reader) Photo {
	var photo Photo
	json.NewDecoder(bytes).Decode(&photo)
	return photo
}

/**
 * Venue
 */
type Venue struct {
	Name      string `json:"name"`
	Id        string `json:"id"`
	BestPhoto Photo  `json:"bestPhoto,omitempty"`
}

func VenueFromMap(data interface{}) Venue {
	b, err := json.Marshal(data)
	if err == nil {
		return VenueFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func VenueFromJson(bytes io.Reader) Venue {
	var venue Venue
	json.NewDecoder(bytes).Decode(&venue)
	return venue
}

/**
 * Venue details response
 */
type VenueDetailsResponse struct {
	Venue Venue `json:"venue"`
}

func VenueDetailsResponseFromMap(data interface{}) VenueDetailsResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return VenueDetailsResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func VenueDetailsResponseFromJson(bytes io.Reader) VenueDetailsResponse {
	var venueDetailsResponse VenueDetailsResponse
	json.NewDecoder(bytes).Decode(&venueDetailsResponse)
	return venueDetailsResponse
}

/**
 * Venue details response wrapper
 */
type VenueDetailsResponseWrapper struct {
	Response VenueDetailsResponse `json:"response"`
}

func VenueDetailsResponseWrapperFromMap(data interface{}) VenueDetailsResponseWrapper {
	b, err := json.Marshal(data)
	if err == nil {
		return VenueDetailsResponseWrapperFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func VenueDetailsResponseWrapperFromJson(bytes io.Reader) VenueDetailsResponseWrapper {
	var venueDetailsResponseWrapper VenueDetailsResponseWrapper
	json.NewDecoder(bytes).Decode(&venueDetailsResponseWrapper)
	return venueDetailsResponseWrapper
}

/**
 * Explore venue response
 */
type VenueExploreResponse struct {
	Groups []VenueGroup `json:"groups"`
}

func VenueExploreResponseFromMap(data interface{}) VenueExploreResponse {
	b, err := json.Marshal(data)
	if err == nil {
		return VenueExploreResponseFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func VenueExploreResponseFromJson(bytes io.Reader) VenueExploreResponse {
	var venueExploreResponse VenueExploreResponse
	json.NewDecoder(bytes).Decode(&venueExploreResponse)
	return venueExploreResponse
}

/**
 * Explore venue response wrapper
 */
type VenueExploreResponseWrapper struct {
	Response VenueExploreResponse `json:"response"`
}

func VenueExploreResponseWrapperFromMap(data interface{}) VenueExploreResponseWrapper {
	b, err := json.Marshal(data)
	if err == nil {
		return VenueExploreResponseWrapperFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func VenueExploreResponseWrapperFromJson(bytes io.Reader) VenueExploreResponseWrapper {
	var venueExploreResponseWrapper VenueExploreResponseWrapper
	json.NewDecoder(bytes).Decode(&venueExploreResponseWrapper)
	return venueExploreResponseWrapper
}

/**
 * Venue group
 */
type VenueGroup struct {
	Items []VenueItem `json:"items"`
}

func VenueGroupFromMap(data interface{}) VenueGroup {
	b, err := json.Marshal(data)
	if err == nil {
		return VenueGroupFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func VenueGroupFromJson(bytes io.Reader) VenueGroup {
	var venueGroup VenueGroup
	json.NewDecoder(bytes).Decode(&venueGroup)
	return venueGroup
}

/**
 * Venue item
 */
type VenueItem struct {
	Venue Venue `json:"venue"`
}

func VenueItemFromMap(data interface{}) VenueItem {
	b, err := json.Marshal(data)
	if err == nil {
		return VenueItemFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func VenueItemFromJson(bytes io.Reader) VenueItem {
	var venueItem VenueItem
	json.NewDecoder(bytes).Decode(&venueItem)
	return venueItem
}

type VenuesGetExploreParams struct {
	ClientId     string
	ClientSecret string
	V            string
	Near         string
	Query        string
}

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

func VenuesGetExplore(client Client, params VenuesGetExploreParams) VenuesGetExploreResponse {

	requestUrl := fmt.Sprintf("%s/venues/explore", client.BaseUrl)
	urlValues := url.Values{}
	if "" != params.ClientId {
		urlValues.Add("client_id", params.ClientId)
	}
	if "" != params.ClientSecret {
		urlValues.Add("client_secret", params.ClientSecret)
	}
	if "" != params.V {
		urlValues.Add("v", params.V)
	}
	if "" != params.Near {
		urlValues.Add("near", params.Near)
	}
	if "" != params.Query {
		urlValues.Add("query", params.Query)
	}

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

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

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

	switch resp.StatusCode {
	case 200:
		return VenuesGetExploreResponse{StatusCode: resp.StatusCode, Response: resp, VenueExploreResponseWrapper: VenueExploreResponseWrapperFromJson(resp.Body)}

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

}

type VenuesGetByVenueIdParams struct {
	ClientId     string
	ClientSecret string
	V            string
}

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

func VenuesGetByVenueId(client Client, venueId string, params VenuesGetByVenueIdParams) VenuesGetByVenueIdResponse {

	requestUrl := fmt.Sprintf("%s/venues/%s", client.BaseUrl, html.EscapeString(venueId))
	urlValues := url.Values{}
	if "" != params.ClientId {
		urlValues.Add("client_id", params.ClientId)
	}
	if "" != params.ClientSecret {
		urlValues.Add("client_secret", params.ClientSecret)
	}
	if "" != params.V {
		urlValues.Add("v", params.V)
	}

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

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

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

	switch resp.StatusCode {
	case 200:
		return VenuesGetByVenueIdResponse{StatusCode: resp.StatusCode, Response: resp, VenueDetailsResponseWrapper: VenueDetailsResponseWrapperFromJson(resp.Body)}

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

}