// Copyright (c) 2016 VMware, Inc. All Rights Reserved.
//
// This product is licensed to you under the Apache License, Version 2.0 (the "License").
// You may not use this product except in compliance with the License.
//
// This product may include a number of subcomponents with separate copyright notices and
// license terms. Your use of these subcomponents is subject to the terms and conditions
// of the subcomponent's license, as noted in the LICENSE file.

package photon

import (
	"bytes"
	"crypto/rand"
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strings"
)

type restClient struct {
	httpClient                *http.Client
	logger                    *log.Logger
	Auth                      *AuthAPI
	UpdateAccessTokenCallback TokenCallback
}

type request struct {
	Method      string
	URL         string
	ContentType string
	Body        io.Reader
	Tokens      *TokenOptions
}

type page struct {
	Items            []interface{} `json:"items"`
	NextPageLink     string        `json:"nextPageLink"`
	PreviousPageLink string        `json:"previousPageLink"`
}

type documentList struct {
	Items []interface{}
}

type bodyRewinder func() io.Reader

const appJson string = "application/json"

// Root URL specifies the API version.
const rootUrl string = "/v1"

// From https://golang.org/src/mime/multipart/writer.go
var quoteEscaper = strings.NewReplacer("\\", "\\\\", `"`, "\\\"")

func (client *restClient) AppendSlice(origSlice []interface{}, dataToAppend []interface{}) []interface{} {
	origLen := len(origSlice)
	newLen := origLen + len(dataToAppend)

	if newLen > cap(origSlice) {
		newSlice := make([]interface{}, (newLen+1)*2)
		copy(newSlice, origSlice)
		origSlice = newSlice
	}

	origSlice = origSlice[0:newLen]
	copy(origSlice[origLen:newLen], dataToAppend)

	return origSlice
}

func (client *restClient) Get(url string, tokens *TokenOptions) (res *http.Response, err error) {
	req := request{"GET", url, "", nil, tokens}
	res, err = client.SendRequest(&req, nil)
	return
}

func (client *restClient) GetList(endpoint string, url string, tokens *TokenOptions) (result []byte, err error) {
	req := request{"GET", url, "", nil, tokens}
	res, err := client.SendRequest(&req, nil)
	if err != nil {
		return
	}
	res, err = getError(res)
	if err != nil {
		return
	}

	decoder := json.NewDecoder(res.Body)
	decoder.UseNumber()

	page := &page{}
	err = decoder.Decode(page)
	if err != nil {
		return
	}

	documentList := &documentList{}
	documentList.Items = client.AppendSlice(documentList.Items, page.Items)

	for page.NextPageLink != "" {
		req = request{"GET", endpoint + page.NextPageLink, "", nil, tokens}
		res, err = client.SendRequest(&req, nil)
		if err != nil {
			return
		}
		res, err = getError(res)
		if err != nil {
			return
		}

		decoder = json.NewDecoder(res.Body)
		decoder.UseNumber()

		page.NextPageLink = ""
		page.PreviousPageLink = ""

		err = decoder.Decode(page)
		if err != nil {
			return
		}

		documentList.Items = client.AppendSlice(documentList.Items, page.Items)
	}

	result, err = json.Marshal(documentList)

	return
}

func (client *restClient) Post(url string, contentType string, body io.ReadSeeker, tokens *TokenOptions) (res *http.Response, err error) {
	res, err = client.SendRequestCommon("POST", url, contentType, body, tokens)
	return
}

func (client *restClient) Patch(url string, contentType string, body io.ReadSeeker, tokens *TokenOptions) (res *http.Response, err error) {
	res, err = client.SendRequestCommon("PATCH", url, contentType, body, tokens)
	return
}

func (client *restClient) Put(url string, contentType string, body io.ReadSeeker, tokens *TokenOptions) (res *http.Response, err error) {
	res, err = client.SendRequestCommon("PUT", url, contentType, body, tokens)
	return
}

func (client *restClient) Delete(url string, tokens *TokenOptions) (res *http.Response, err error) {
	req := request{"DELETE", url, "", nil, tokens}
	res, err = client.SendRequest(&req, nil)
	return
}

func (client *restClient) SendRequestCommon(method string, url string, contentType string, body io.ReadSeeker, tokens *TokenOptions) (res *http.Response, err error) {
	if contentType == "" {
		contentType = appJson
	}

	req := request{method, url, contentType, body, tokens}
	rewinder := func() io.Reader {
		body.Seek(0, 0)
		return body
	}
	res, err = client.SendRequest(&req, rewinder)
	return
}

func (client *restClient) SendRequest(req *request, bodyRewinder bodyRewinder) (res *http.Response, err error) {
	res, err = client.sendRequestHelper(req)
	// In most cases, we'll return immediately
	// If the operation succeeded, but we got a 401 response and if we're using
	// authentication, then we'll look into the body to see if the token expired
	if err != nil {
		return res, err
	}
	if res.StatusCode != 401 {
		// It's not a 401, so the token didn't expire
		return res, err
	}
	if req.Tokens == nil || req.Tokens.AccessToken == "" {
		// We don't have a token, so we can't renew the token, no need to proceed
		return res, err
	}

	// We're going to look in the body to see if it failed because the token expired
	// This means we need to read the body, but the functions that call us also
	// expect to read the body. So we read the body, then create a new reader
	// so they can read the body as normal.
	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		return res, err
	}
	res.Body = ioutil.NopCloser(bytes.NewReader(body))

	// Now see if we had an expired token or not
	var apiError ApiError
	err = json.Unmarshal(body, &apiError)
	if err != nil {
		return res, err
	}
	if apiError.Code != "ExpiredAuthToken" {
		return res, nil
	}

	// We were told that the access token expired, so try to renew it.
	// Note that this looks recursive because GetTokensByRefreshToken() will
	// call the /auth API, and therefore SendRequest(). However, it calls
	// without a token, so we avoid having a loop
	newTokens, err := client.Auth.GetTokensByRefreshToken(req.Tokens.RefreshToken)
	if err != nil {
		return res, err
	}
	req.Tokens.AccessToken = newTokens.AccessToken
	if client.UpdateAccessTokenCallback != nil {
		client.UpdateAccessTokenCallback(newTokens.AccessToken)
	}
	if req.Body != nil && bodyRewinder != nil {
		req.Body = bodyRewinder()
	}
	res, err = client.sendRequestHelper(req)
	return res, nil
}

func (client *restClient) sendRequestHelper(req *request) (res *http.Response, err error) {
	r, err := http.NewRequest(req.Method, req.URL, req.Body)
	if err != nil {
		client.logger.Printf("An error occured creating request %s on %s. Error: %s", req.Method, req.URL, err)
		return
	}
	if req.ContentType != "" {
		r.Header.Add("Content-Type", req.ContentType)
	}
	if req.Tokens != nil && req.Tokens.AccessToken != "" {
		r.Header.Add("Authorization", "Bearer "+req.Tokens.AccessToken)
	}
	res, err = client.httpClient.Do(r)
	if err != nil {
		client.logger.Printf("An error occured when calling %s on %s. Error: %s", req.Method, req.URL, err)
		return
	}

	client.logger.Printf("[%s] %s - %s %s", res.Header.Get("request-id"), res.Status, req.Method, req.URL)
	return
}

func (client *restClient) MultipartUploadFile(url, filePath string, params map[string]string, tokens *TokenOptions) (res *http.Response, err error) {
	file, err := os.Open(filePath)
	if err != nil {
		return
	}
	defer file.Close()
	return client.MultipartUpload(url, file, filepath.Base(filePath), params, tokens)
}

func (client *restClient) MultipartUpload(url string, reader io.ReadSeeker, filename string, params map[string]string, tokens *TokenOptions) (res *http.Response, err error) {
	boundary := client.randomBoundary()
	multiReader, contentType := client.createMultiReader(reader, filename, params, boundary)
	rewinder := func() io.Reader {
		reader.Seek(0, 0)
		multiReader, _ := client.createMultiReader(reader, filename, params, boundary)
		return multiReader
	}
	res, err = client.SendRequest(&request{"POST", url, contentType, multiReader, tokens}, rewinder)

	return
}

func (client *restClient) createMultiReader(reader io.ReadSeeker, filename string, params map[string]string, boundary string) (io.Reader, string) {
	// The mime/multipart package does not support streaming multipart data from disk,
	// at least not without complicated, problematic goroutines that simultaneously read/write into a buffer.
	// A much easier approach is to just construct the multipart request by hand, using io.MultiPart to
	// concatenate the parts of the request together into a single io.Reader.
	parts := []io.Reader{}

	// Create a part for each key, val pair in params
	for k, v := range params {
		parts = append(parts, client.createFieldPart(k, v, boundary))
	}

	start := fmt.Sprintf("\r\n--%s\r\n", boundary)
	start += fmt.Sprintf("Content-Disposition: form-data; name=\"file\"; filename=\"%s\"\r\n", quoteEscaper.Replace(filename))
	start += fmt.Sprintf("Content-Type: application/octet-stream\r\n\r\n")
	end := fmt.Sprintf("\r\n--%s--", boundary)

	// The request will consist of a reader to begin the request, a reader which points
	// to the file data on disk, and a reader containing the closing boundary of the request.
	parts = append(parts, strings.NewReader(start), reader, strings.NewReader(end))

	contentType := fmt.Sprintf("multipart/form-data; boundary=%s", boundary)

	return io.MultiReader(parts...), contentType
}

// From https://golang.org/src/mime/multipart/writer.go
func (client *restClient) randomBoundary() string {
	var buf [30]byte
	_, err := io.ReadFull(rand.Reader, buf[:])
	if err != nil {
		panic(err)
	}
	return fmt.Sprintf("%x", buf[:])
}

// Creates a reader that encapsulates a single multipart form part
func (client *restClient) createFieldPart(fieldname, value, boundary string) io.Reader {
	str := fmt.Sprintf("\r\n--%s\r\n", boundary)
	str += fmt.Sprintf("Content-Disposition: form-data; name=\"%s\"\r\n\r\n", quoteEscaper.Replace(fieldname))
	str += value
	return strings.NewReader(str)
}