client.go

package bingo

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strings"
	"time"

	"dev.freespoke.com/bingo/v2/bingtypes"
)

const (
	authHeaderName   = "Ocp-Apim-Subscription-Key"
	defaultUserAgent = "FreedomFries (Bingo v1.0)"
)

type client struct {
	HTTP      *http.Client
	APIKey    string
	UserAgent string
}

type requestOpts interface {
	toQueryString(v *url.Values)
	toHeader(userAgent string, h *http.Header)
}

func (c *client) makeGetRequest(
	ctx context.Context,
	baseURL string,
	path string,
	opts requestOpts,
) (*http.Request, error) {
	requestURL := fmt.Sprintf("%s/%s",
		strings.TrimRight(baseURL, "/"),
		strings.TrimLeft(path, "/"),
	)

	u, err := url.Parse(requestURL)
	if err != nil {
		return nil, err
	}

	q := u.Query()
	opts.toQueryString(&q)
	u.RawQuery = encodeBingParams(q)

	headers := http.Header{}
	opts.toHeader(c.UserAgent, &headers)

	req, err := http.NewRequestWithContext(ctx, "GET", u.String(), nil)
	if err != nil {
		return nil, err
	}

	req.Header = headers

	return req, nil
}

func (c *client) sendRequest(req *http.Request, params RequestParams) (*http.Response, error) {
	req.Header.Set("Accept", "application/json")
	req.Header.Set(authHeaderName, c.APIKey)

	ua := params.UserAgent
	if ua == "" {
		ua = defaultUserAgent
	}
	req.Header.Set("User-Agent", ua)

	res, err := c.HTTP.Do(req)
	if err != nil {
		return res, err
	}

	var e bingtypes.ErrorResponse
	if res.StatusCode == 404 || res.StatusCode == 401 {
		e.Err = res.Status
		return res, e
	} else if res.StatusCode >= 400 {
		err = json.NewDecoder(res.Body).Decode(&e)
		if err != nil {
			return res, err
		}

		return res, e
	}

	return res, nil
}

func (c *client) getResponseMetadata(res *http.Response) *bingtypes.ResponseMetadata {
	return &bingtypes.ResponseMetadata{
		Market:     res.Header.Get("BingAPIs-Market"),
		TraceID:    res.Header.Get("BingAPIs-TraceId"),
		RetryAfter: res.Header.Get("Retry-After"),
		ClientID:   res.Header.Get("x-MSEdge-ClientID"),
	}
}

type RequestParams struct {
	CountryCode     string
	Count           int
	Market          string
	Offset          int
	SafeSearch      string
	SetLang         string
	freshness       string
	TextDecorations bool
	TextFormat      string

	// UserAgent may be specified if you do not wish to use the default client
	// library UA. If set, this should be a pass-through from the requesting
	// end user. Bing may serve different responses better tailored for the user
	// (e.g. mobile-optimized sites).
	UserAgent string
}

func (o *RequestParams) WithFreshness(f bingtypes.Freshness) {
	o.freshness = f.String()
}

func (o *RequestParams) WithCustomFreshness(start, end *time.Time) {
	if start == nil || start.IsZero() {
		return
	}

	o.freshness = start.Format("2006-01-02")
	if end != nil && !end.IsZero() {
		o.freshness = fmt.Sprintf("%s..%s", start.Format("2006-01-02"), end.Format("2006-01-02"))
	}
}

func (o RequestParams) toQueryString(v *url.Values) {
	if o.CountryCode != "" {
		v.Add("cc", o.CountryCode)
	}

	if o.Count != 0 {
		v.Add("count", fmt.Sprint(o.Count))
	}

	v.Add("offset", fmt.Sprint(o.Offset))

	if o.Market != "" {
		v.Add("mkt", o.Market)
	}

	if o.SafeSearch != "" {
		v.Add("safeSearch", o.SafeSearch)
	}

	if o.SetLang != "" {
		v.Add("setLang", o.SetLang)
	} else if o.Market != "" {
		v.Add("setLang", o.Market)
	}

	if o.freshness != "" {
		v.Add("freshness", o.freshness)
	}

	if o.TextDecorations {
		v.Add("textDecorations", "true")
	}

	if o.TextFormat != "" {
		v.Add("textFormat", o.TextFormat)
	}
}

type RequestHeaders struct {
	AcceptLanguage []string
	Pragma         string
	ClientID       string
	ClientIP       string
	SearchLocation map[string]string
}

func (o RequestHeaders) toHeader(userAgent string, h *http.Header) {
	if len(o.AcceptLanguage) != 0 {
		h.Add("Accept-Language", strings.Join(o.AcceptLanguage, ","))
	}

	if o.ClientID != "" {
		h.Add("X-MSEdge-ClientID", o.ClientID)
	}

	if o.ClientIP != "" {
		h.Add("X-MSEdge-ClientIP", o.ClientIP)
	}

	if len(o.SearchLocation) > 0 {
		var loc []string
		for k, v := range o.SearchLocation {
			loc = append(loc, fmt.Sprintf(
				"%s:%s",
				k,
				v,
			))
		}

		h.Add("X-Search-Location", strings.Join(loc, ";"))
	}

	if o.Pragma != "" {
		h.Add("Pragma", o.Pragma)
	}

	h.Add("User-Agent", userAgent)
}

func makeBaseURL(baseURL string, path string) string {
	return fmt.Sprintf("%s/%s", strings.TrimRight(baseURL, "/"), strings.TrimLeft(path, "/"))
}

// encodingBingParams fixes query encoding for Bing which isn't fully standards compliant.
// Bing blows up if responseFilter has commas urlencoded as %2C.
// These need to be put back to the original, unencoded commas.
func encodeBingParams(v url.Values) string {
	for k := range v {
		if strings.ToLower(k) == "responsefilter" {
			f := url.QueryEscape(v.Get(k))
			v.Del(k)
			res := v.Encode() + "&" + k + "=" + strings.ReplaceAll(f, "%2C", ",")
			return res
		}
	}

	return v.Encode()
}