package utils

import (
	"io"
	"net/http"
	"strings"

	log "github.com/Sirupsen/logrus"
)

// VersionInfo is used to model entities which has a version.
// It is basically a tupple with name and version.
type VersionInfo interface {
	Name() string
	Version() string
}

func validVersion(version VersionInfo) bool {
	const stopChars = " \t\r\n/"
	name := version.Name()
	vers := version.Version()
	if len(name) == 0 || strings.ContainsAny(name, stopChars) {
		return false
	}
	if len(vers) == 0 || strings.ContainsAny(vers, stopChars) {
		return false
	}
	return true
}

// Convert versions to a string and append the string to the string base.
//
// Each VersionInfo will be converted to a string in the format of
// "product/version", where the "product" is get from the Name() method, while
// version is get from the Version() method. Several pieces of verson information
// will be concatinated and separated by space.
func appendVersions(base string, versions ...VersionInfo) string {
	if len(versions) == 0 {
		return base
	}

	verstrs := make([]string, 0, 1+len(versions))
	if len(base) > 0 {
		verstrs = append(verstrs, base)
	}

	for _, v := range versions {
		if !validVersion(v) {
			continue
		}
		verstrs = append(verstrs, v.Name()+"/"+v.Version())
	}
	return strings.Join(verstrs, " ")
}

// HTTPRequestDecorator is used to change an instance of
// http.Request. It could be used to add more header fields,
// change body, etc.
type HTTPRequestDecorator interface {
	// ChangeRequest() changes the request accordingly.
	// The changed request will be returned or err will be non-nil
	// if an error occur.
	ChangeRequest(req *http.Request) (newReq *http.Request, err error)
}

// HTTPUserAgentDecorator appends the product/version to the user agent field
// of a request.
type HTTPUserAgentDecorator struct {
	versions []VersionInfo
}

func NewHTTPUserAgentDecorator(versions ...VersionInfo) HTTPRequestDecorator {
	return &HTTPUserAgentDecorator{
		versions: versions,
	}
}

func (h *HTTPUserAgentDecorator) ChangeRequest(req *http.Request) (newReq *http.Request, err error) {
	if req == nil {
		return req, nil
	}

	userAgent := appendVersions(req.UserAgent(), h.versions...)
	if len(userAgent) > 0 {
		req.Header.Set("User-Agent", userAgent)
	}
	return req, nil
}

type HTTPMetaHeadersDecorator struct {
	Headers map[string][]string
}

func (h *HTTPMetaHeadersDecorator) ChangeRequest(req *http.Request) (newReq *http.Request, err error) {
	if h.Headers == nil {
		return req, nil
	}
	for k, v := range h.Headers {
		req.Header[k] = v
	}
	return req, nil
}

type HTTPAuthDecorator struct {
	login    string
	password string
}

func NewHTTPAuthDecorator(login, password string) HTTPRequestDecorator {
	return &HTTPAuthDecorator{
		login:    login,
		password: password,
	}
}

func (self *HTTPAuthDecorator) ChangeRequest(req *http.Request) (*http.Request, error) {
	req.SetBasicAuth(self.login, self.password)
	return req, nil
}

// HTTPRequestFactory creates an HTTP request
// and applies a list of decorators on the request.
type HTTPRequestFactory struct {
	decorators []HTTPRequestDecorator
}

func NewHTTPRequestFactory(d ...HTTPRequestDecorator) *HTTPRequestFactory {
	return &HTTPRequestFactory{
		decorators: d,
	}
}

func (self *HTTPRequestFactory) AddDecorator(d ...HTTPRequestDecorator) {
	self.decorators = append(self.decorators, d...)
}

func (self *HTTPRequestFactory) GetDecorators() []HTTPRequestDecorator {
	return self.decorators
}

// NewRequest() creates a new *http.Request,
// applies all decorators in the HTTPRequestFactory on the request,
// then applies decorators provided by d on the request.
func (h *HTTPRequestFactory) NewRequest(method, urlStr string, body io.Reader, d ...HTTPRequestDecorator) (*http.Request, error) {
	req, err := http.NewRequest(method, urlStr, body)
	if err != nil {
		return nil, err
	}

	// By default, a nil factory should work.
	if h == nil {
		return req, nil
	}
	for _, dec := range h.decorators {
		req, err = dec.ChangeRequest(req)
		if err != nil {
			return nil, err
		}
	}
	for _, dec := range d {
		req, err = dec.ChangeRequest(req)
		if err != nil {
			return nil, err
		}
	}
	log.Debugf("%v -- HEADERS: %v", req.URL, req.Header)
	return req, err
}