package storebackapi

/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.2.6
 * User agent: apibuilder app.apibuilder.io/bombas/storeback-api/0.2.6/go_1_5_client
 */

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

const BaseUrl = "https://bombas-storeback-api.global.ssl.fastly.net/v1"
const UserAgent = "apibuilder app.apibuilder.io/bombas/storeback-api/0.2.6/go_1_5_client"
const Version = "0.2.6"
const VersionMajor = 0

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

type Product struct {
	Id              int64                    `json:"id,omitempty"`
	Title           string                   `json:"title,omitempty"`
	Handle          string                   `json:"handle,omitempty"`
	Description     string                   `json:"description,omitempty"`
	DescriptionHtml string                   `json:"description_html,omitempty"`
	ItemCount       int32                    `json:"item_count,omitempty"`
	ProductType     string                   `json:"product_type,omitempty"`
	Gender          string                   `json:"gender,omitempty"`
	Colors          []Color                  `json:"colors,omitempty"`
	Sizes           []Size                   `json:"sizes,omitempty"`
	Images          []map[string]interface{} `json:"images,omitempty"`
	Variants        []Variant                `json:"variants,omitempty"`
	Breadcrumbs     []Breadcrumb             `json:"breadcrumbs,omitempty"`
	Details         []Detail                 `json:"details,omitempty"`
	CreatedAt       string                   `json:"created_at,omitempty"`
	UpdatedAt       string                   `json:"updated_at,omitempty"`
}

func ProductFromMap(data interface{}) Product {
	b, err := json.Marshal(data)
	if err == nil {
		return ProductFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ProductFromJson(bytes io.Reader) Product {
	var product Product
	json.NewDecoder(bytes).Decode(&product)
	return product
}

/**
 * A particular size options for a product
 */
type Size struct {
	Name   string       `json:"name,omitempty"`
	Values []SizeValues `json:"values,omitempty"`
}

func SizeFromMap(data interface{}) Size {
	b, err := json.Marshal(data)
	if err == nil {
		return SizeFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func SizeFromJson(bytes io.Reader) Size {
	var size Size
	json.NewDecoder(bytes).Decode(&size)
	return size
}

type SizeValues struct {
	Id       string `json:"id,omitempty"`
	Name     string `json:"name,omitempty"`
	Guidance string `json:"guidance,omitempty"`
}

func SizeValuesFromMap(data interface{}) SizeValues {
	b, err := json.Marshal(data)
	if err == nil {
		return SizeValuesFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func SizeValuesFromJson(bytes io.Reader) SizeValues {
	var sizeValues SizeValues
	json.NewDecoder(bytes).Decode(&sizeValues)
	return sizeValues
}

type Color struct {
	Id       string `json:"id,omitempty"`
	Position int32  `json:"position,omitempty"`
	Name     string `json:"name,omitempty"`
	Fill     string `json:"fill,omitempty"`
}

func ColorFromMap(data interface{}) Color {
	b, err := json.Marshal(data)
	if err == nil {
		return ColorFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ColorFromJson(bytes io.Reader) Color {
	var color Color
	json.NewDecoder(bytes).Decode(&color)
	return color
}

type Variant struct {
	Id          int64    `json:"id,omitempty"`
	ProductId   int64    `json:"product_id,omitempty"`
	Sku         string   `json:"sku,omitempty"`
	Title       string   `json:"title,omitempty"`
	IsAvailable string   `json:"is_available,omitempty"`
	Price       Price    `json:"price,omitempty"`
	Shipping    Shipping `json:"shipping,omitempty"`
	CreatedAt   string   `json:"created_at,omitempty"`
	UpdatedAt   string   `json:"updated_at,omitempty"`
	Sizes       []Size   `json:"sizes,omitempty"`
}

func VariantFromMap(data interface{}) Variant {
	b, err := json.Marshal(data)
	if err == nil {
		return VariantFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func VariantFromJson(bytes io.Reader) Variant {
	var variant Variant
	json.NewDecoder(bytes).Decode(&variant)
	return variant
}

type Shipping struct {
	RequiresShipping string `json:"requires_shipping,omitempty"`
	Grams            int32  `json:"grams,omitempty"`
	Weight           int32  `json:"weight,omitempty"`
	WeightUnit       string `json:"weight_unit,omitempty"`
}

func ShippingFromMap(data interface{}) Shipping {
	b, err := json.Marshal(data)
	if err == nil {
		return ShippingFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ShippingFromJson(bytes io.Reader) Shipping {
	var shipping Shipping
	json.NewDecoder(bytes).Decode(&shipping)
	return shipping
}

type Breadcrumb struct {
	Name     string `json:"name,omitempty"`
	Link     string `json:"link,omitempty"`
	Position int32  `json:"position,omitempty"`
}

func BreadcrumbFromMap(data interface{}) Breadcrumb {
	b, err := json.Marshal(data)
	if err == nil {
		return BreadcrumbFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func BreadcrumbFromJson(bytes io.Reader) Breadcrumb {
	var breadcrumb Breadcrumb
	json.NewDecoder(bytes).Decode(&breadcrumb)
	return breadcrumb
}

type Image struct {
	Id       int32  `json:"id,omitempty"`
	Position int32  `json:"position,omitempty"`
	Alt      string `json:"alt,omitempty"`
	Src      string `json:"src,omitempty"`
}

func ImageFromMap(data interface{}) Image {
	b, err := json.Marshal(data)
	if err == nil {
		return ImageFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func ImageFromJson(bytes io.Reader) Image {
	var image Image
	json.NewDecoder(bytes).Decode(&image)
	return image
}

type Price struct {
	Msrp         string `json:"msrp,omitempty"`
	Price        string `json:"price,omitempty"`
	IsDiscounted string `json:"isDiscounted,omitempty"`
	PercentOff   string `json:"percentOff,omitempty"`
}

func PriceFromMap(data interface{}) Price {
	b, err := json.Marshal(data)
	if err == nil {
		return PriceFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func PriceFromJson(bytes io.Reader) Price {
	var price Price
	json.NewDecoder(bytes).Decode(&price)
	return price
}

type Detail struct {
	IconHandle string `json:"icon_handle,omitempty"`
	Title      string `json:"title,omitempty"`
	Tech       []Tech `json:"tech,omitempty"`
}

func DetailFromMap(data interface{}) Detail {
	b, err := json.Marshal(data)
	if err == nil {
		return DetailFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func DetailFromJson(bytes io.Reader) Detail {
	var detail Detail
	json.NewDecoder(bytes).Decode(&detail)
	return detail
}

type Tech struct {
	Title   string `json:"title,omitempty"`
	Handle  string `json:"handle,omitempty"`
	Content string `json:"content,omitempty"`
}

func TechFromMap(data interface{}) Tech {
	b, err := json.Marshal(data)
	if err == nil {
		return TechFromJson(bytes.NewReader(b))
	} else {
		panic(err)
	}
}

func TechFromJson(bytes io.Reader) Tech {
	var tech Tech
	json.NewDecoder(bytes).Decode(&tech)
	return tech
}

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

func ProductsGet(client Client, productId string) ProductsGetResponse {

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

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

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

	switch resp.StatusCode {
	case 200:
		return ProductsGetResponse{StatusCode: resp.StatusCode, Response: resp, Product: ProductFromJson(resp.Body)}

	case 400:
		return ProductsGetResponse{StatusCode: resp.StatusCode, Response: resp}

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

	case resp.StatusCode >= 200 && resp.StatusCode < 300:
		// TODO

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

}