// Package samawards is a typed client for the SAM.gov Contract Awards API
// (open.gsa.gov/api/contract-awards), the RESTful replacement for the retiring FPDS Atom feed. It
// fetches federal contract award and incumbent data using the same SAM api_key the opportunities feed
// uses, and normalizes it to a flat app shape. It has no database dependency: it fetches and
// normalizes, the ingest writes the cache. The api_key is held here and only ever added as a query
// parameter, never logged or placed in an error string.
package samawards

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"
)

// Base endpoints. Prod is the default; the alpha (prodlike) is selectable via the env for testing.
const (
	BaseProd  = "https://api.sam.gov/contract-awards/v1/search"
	BaseAlpha = "https://api-alpha.sam.gov/contract-awards/v1/search"
)

const (
	maxLimit     = 100    // the API caps a page at 100
	offsetWindow = 400000 // offset times limit may not exceed this
	throttleCap  = 1024   // max body bytes captured from a 429
	pageGap      = 250 * time.Millisecond
)

// ErrThrottled is the sentinel for a 429 (daily quota). Detect with errors.Is(err, ErrThrottled).
var ErrThrottled = errors.New("samawards: rate limited (429)")

// ThrottleError carries the Retry-After hint. It satisfies errors.Is(err, ErrThrottled).
type ThrottleError struct {
	RetryAfter string
	Body       string
}

func (e *ThrottleError) Error() string {
	if e.RetryAfter != "" {
		return fmt.Sprintf("samawards: rate limited (429), retry after %s", e.RetryAfter)
	}
	return "samawards: rate limited (429)"
}

func (e *ThrottleError) Is(target error) bool { return target == ErrThrottled }

// Client is a typed Contract Awards client over the built in net/http.
type Client struct {
	base string
	key  string
	http *http.Client
}

// New builds a client. An empty base defaults to prod.
func New(base, key string) *Client {
	if strings.TrimSpace(base) == "" {
		base = BaseProd
	}
	return &Client{base: base, key: key, http: &http.Client{Timeout: 60 * time.Second}}
}

// SearchParams are the supported filters. NAICS is up to 100 codes (the API joins them with a tilde).
// Department is a partial contracting department name (for example DEFENSE). AwardeeUEIs scopes to
// specific recipients for own past performance. The Signed window filters by dateSigned.
type SearchParams struct {
	NAICS       []string
	Department  string
	AwardeeUEIs []string
	SignedFrom  time.Time
	SignedTo    time.Time
	Limit       int
	Offset      int
}

// SearchResult is one page: the raw award records and the total match count the API reports.
type SearchResult struct {
	Records []json.RawMessage
	Total   int
}

// Search fetches one page. It maps a 429 to *ThrottleError and any other non 200 to an error that never
// includes the api_key.
func (c *Client) Search(ctx context.Context, p SearchParams) (SearchResult, error) {
	limit := p.Limit
	if limit < 1 {
		limit = 10
	}
	if limit > maxLimit {
		limit = maxLimit
	}
	q := url.Values{}
	q.Set("api_key", c.key)
	q.Set("limit", strconv.Itoa(limit))
	q.Set("offset", strconv.Itoa(p.Offset))
	if len(p.NAICS) > 0 {
		q.Set("naicsCode", strings.Join(cap100(p.NAICS), "~"))
	}
	if d := strings.TrimSpace(p.Department); d != "" {
		q.Set("contractingDepartmentName", d)
	}
	if len(p.AwardeeUEIs) > 0 {
		q.Set("awardeeUniqueEntityId", strings.Join(cap100(p.AwardeeUEIs), "~"))
	}
	if !p.SignedFrom.IsZero() && !p.SignedTo.IsZero() {
		q.Set("dateSigned", fmt.Sprintf("[%s,%s]", p.SignedFrom.Format("01/02/2006"), p.SignedTo.Format("01/02/2006")))
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.base+"?"+q.Encode(), nil)
	if err != nil {
		// The error embeds the full URL including the api_key, so return a generic message.
		return SearchResult{}, errors.New("samawards: failed to build request")
	}
	req.Header.Set("Accept", "application/json")

	resp, err := c.http.Do(req)
	if err != nil {
		return SearchResult{}, fmt.Errorf("samawards: request: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusTooManyRequests {
		body, _ := io.ReadAll(io.LimitReader(resp.Body, throttleCap))
		return SearchResult{}, &ThrottleError{RetryAfter: resp.Header.Get("Retry-After"), Body: string(body)}
	}
	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(io.LimitReader(resp.Body, throttleCap))
		return SearchResult{}, fmt.Errorf("samawards: status %d: %s", resp.StatusCode, strings.TrimSpace(string(body)))
	}

	var env struct {
		AwardSummary []json.RawMessage `json:"awardSummary"`
		TotalRecords NumericText       `json:"totalRecords"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
		return SearchResult{}, fmt.Errorf("samawards: decode: %w", err)
	}
	return SearchResult{Records: env.AwardSummary, Total: env.TotalRecords.Int()}, nil
}

// NumericText decodes a field the Contract Awards API returns inconsistently as either a JSON number or
// a quoted string (totalRecords and the dollar amounts both arrive as strings) into the literal text, so
// both forms parse the same way downstream. This was a real wire mismatch: the count and the dollars are
// strings on the wire, which a plain int or json.Number field cannot decode.
type NumericText string

// UnmarshalJSON accepts a JSON number, a quoted string, or null.
func (t *NumericText) UnmarshalJSON(b []byte) error {
	s := strings.TrimSpace(string(b))
	if s == "null" {
		*t = ""
		return nil
	}
	*t = NumericText(strings.TrimSpace(strings.Trim(s, `"`)))
	return nil
}

// Int parses the text as an integer, tolerating a decimal point. It returns 0 when the text is empty or
// unparseable, which for a record count safely stops pagination rather than looping.
func (t NumericText) Int() int {
	s := string(t)
	if n, err := strconv.Atoi(s); err == nil {
		return n
	}
	if f, err := strconv.ParseFloat(s, 64); err == nil {
		return int(f)
	}
	return 0
}

// SearchAll paginates by offset up to pageCap pages, stopping at the total or the API offset ceiling. On
// a 429 it returns the records collected so far together with ErrThrottled so the caller keeps the
// partial pull and stops gracefully.
func (c *Client) SearchAll(ctx context.Context, p SearchParams, pageCap int) (recs []json.RawMessage, total int, capped bool, err error) {
	limit := p.Limit
	if limit < 1 {
		limit = maxLimit
	}
	if limit > maxLimit {
		limit = maxLimit
	}
	for page := 0; page < pageCap; page++ {
		pp := p
		pp.Limit = limit
		pp.Offset = page * limit
		if pp.Offset+limit > offsetWindow {
			capped = true
			break
		}
		res, e := c.Search(ctx, pp)
		if e != nil {
			if errors.Is(e, ErrThrottled) {
				return recs, total, true, ErrThrottled
			}
			return recs, total, capped, e
		}
		total = res.Total
		recs = append(recs, res.Records...)
		if len(res.Records) < limit || len(recs) >= total {
			return recs, total, capped, nil
		}
		select {
		case <-ctx.Done():
			return recs, total, true, ctx.Err()
		case <-time.After(pageGap):
		}
	}
	if len(recs) < total {
		capped = true
	}
	return recs, total, capped, nil
}

// cap100 caps a slice to the API limit of 100 values per multi value parameter.
func cap100(s []string) []string {
	if len(s) > 100 {
		return s[:100]
	}
	return s
}