client.go

package checkhost

import (
	"bytes"
	"compress/gzip"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"strings"
	"time"
)

// maybeDecompress checks for a gzip magic header (0x1f 0x8b) or a
// Content-Encoding: gzip response header and inflates the body if either
// is present. The Check-Host API edge compresses large JSON bodies (e.g.
// /locations) regardless of the Accept-Encoding request header.
func maybeDecompress(body []byte, encoding string) []byte {
	gzippedByMagic := len(body) >= 2 && body[0] == 0x1f && body[1] == 0x8b
	gzippedByHeader := strings.EqualFold(encoding, "gzip")
	if !gzippedByMagic && !gzippedByHeader {
		return body
	}
	gzr, err := gzip.NewReader(bytes.NewReader(body))
	if err != nil {
		return body
	}
	defer gzr.Close()
	dec, err := io.ReadAll(gzr)
	if err != nil {
		return body
	}
	return dec
}

const (
	DefaultBaseURL = "https://api.check-host.cc"
)

// CheckHostException mapped as a generic Go error.
var (
	ErrRateLimit   = errors.New("rate limit reached, please provide an API key or slow down your requests")
	ErrBadRequest  = errors.New("problem with your input parameters, please check your payload")
	ErrServerError = errors.New("internal server error, please try again later")
)

type CheckHost struct {
	APIKey     string
	BaseURL    string
	HTTPClient *http.Client
}

// NewClient creates a new CheckHost client. The apiKey is optional.
func NewClient(apiKey string) *CheckHost {
	return &CheckHost{
		APIKey: apiKey,
		BaseURL: DefaultBaseURL,
		HTTPClient: &http.Client{
			Timeout: 30 * time.Second,
		},
	}
}

// doRequest performs the HTTP request and unmarshals the response.
func (c *CheckHost) doRequest(method, path string, body interface{}, response interface{}) error {
	var buf io.Reader
	if body != nil {
		b, err := json.Marshal(body)
		if err != nil {
			return fmt.Errorf("error marshaling request body: %w", err)
		}
		buf = bytes.NewBuffer(b)
	}

	url := fmt.Sprintf("%s/%s", c.BaseURL, path)
	req, err := http.NewRequest(method, url, buf)
	if err != nil {
		return fmt.Errorf("error creating request: %w", err)
	}

	req.Header.Set("Accept", "application/json")
	if body != nil {
		req.Header.Set("Content-Type", "application/json")
	}

	resp, err := c.HTTPClient.Do(req)
	if err != nil {
		return fmt.Errorf("network error occurred during request: %w", err)
	}
	defer resp.Body.Close()

	respBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return fmt.Errorf("error reading response body: %w", err)
	}
	respBody = maybeDecompress(respBody, resp.Header.Get("Content-Encoding"))

	// Handle specific HTTP Status Codes based on check-host API spec
	switch resp.StatusCode {
	case 200:
		// Success
	case 400:
		return fmt.Errorf("%w: %s", ErrBadRequest, string(respBody))
	case 429:
		return fmt.Errorf("%w: %s", ErrRateLimit, string(respBody))
	case 500:
		return fmt.Errorf("%w: %s", ErrServerError, string(respBody))
	default:
		if resp.StatusCode >= 400 {
			return fmt.Errorf("check-host api returned an unexpected status code %d: %s", resp.StatusCode, string(respBody))
		}
	}

	// Unmarshal JSON to the provided response pointer, if any
	if response != nil && len(respBody) > 0 {
		err = json.Unmarshal(respBody, response)
		if err != nil {
			// Some endpoints like /myip simply return a string text/plain
			if strResp, ok := response.(*string); ok {
				*strResp = string(respBody)
				return nil
			}
			return fmt.Errorf("error parsing response as json: %w. response text: %s", err, string(respBody))
		}
	}

	return nil
}

// doRequestRaw performs a GET request and returns the raw response body
// without trying to JSON-decode it. Used for binary endpoints
// (og-image PNG, country-map PNG/SVG).
func (c *CheckHost) doRequestRaw(path, accept string) ([]byte, error) {
	url := fmt.Sprintf("%s/%s", c.BaseURL, path)
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %w", err)
	}
	if accept == "" {
		accept = "*/*"
	}
	req.Header.Set("Accept", accept)

	resp, err := c.HTTPClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("network error occurred during request: %w", err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("error reading response body: %w", err)
	}
	// Don't decompress binary responses (PNG / SVG) - the body IS the image.

	switch resp.StatusCode {
	case 200:
		return body, nil
	case 400:
		return nil, fmt.Errorf("%w: %s", ErrBadRequest, string(body))
	case 429:
		return nil, fmt.Errorf("%w: %s", ErrRateLimit, string(body))
	case 500:
		return nil, fmt.Errorf("%w: %s", ErrServerError, string(body))
	default:
		return nil, fmt.Errorf("check-host api returned an unexpected status code %d: %s", resp.StatusCode, string(body))
	}
}