package promoauth

import (
	"net/http"
	"strconv"
	"time"

	"golang.org/x/xerrors"
)

type rateLimits struct {
	Limit     int
	Remaining int
	Used      int
	Reset     time.Time
	Resource  string
}

// githubRateLimits returns rate limit information from a GitHub response.
// GitHub rate limits are on a per-user basis, and tracking each user as
// a prometheus label might be too much. So only track rate limits for
// unauthorized responses.
//
// Unauthorized responses have a much stricter rate limit of 60 per hour.
// Tracking this is vital to ensure we do not hit the limit.
func githubRateLimits(resp *http.Response, err error) (rateLimits, bool) {
	if err != nil || resp == nil {
		return rateLimits{}, false
	}

	// Only track 401 responses which indicates we are using the 60 per hour
	// rate limit.
	if resp.StatusCode != http.StatusUnauthorized {
		return rateLimits{}, false
	}

	p := headerParser{header: resp.Header}
	// See
	// https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api?apiVersion=2022-11-28#checking-the-status-of-your-rate-limit
	limits := rateLimits{
		Limit:     p.int("x-ratelimit-limit"),
		Remaining: p.int("x-ratelimit-remaining"),
		Used:      p.int("x-ratelimit-used"),
		Resource:  p.string("x-ratelimit-resource") + "-unauthorized",
	}

	if limits.Limit == 0 &&
		limits.Remaining == 0 &&
		limits.Used == 0 {
		// For some requests, github has no rate limit. In which case,
		// it returns all 0s. We can just omit these.
		return limits, false
	}

	// Reset is when the rate limit "used" will be reset to 0.
	// If it's unix 0, then we do not know when it will reset.
	// Change it to a zero time as that is easier to handle in golang.
	unix := p.int("x-ratelimit-reset")
	resetAt := time.Unix(int64(unix), 0)
	if unix == 0 {
		resetAt = time.Time{}
	}
	limits.Reset = resetAt

	if len(p.errors) > 0 {
		// If we are missing any headers, then do not try and guess
		// what the rate limits are.
		return limits, false
	}
	return limits, true
}

type headerParser struct {
	errors map[string]error
	header http.Header
}

func (p *headerParser) string(key string) string {
	if p.errors == nil {
		p.errors = make(map[string]error)
	}

	v := p.header.Get(key)
	if v == "" {
		p.errors[key] = xerrors.Errorf("missing header %q", key)
	}
	return v
}

func (p *headerParser) int(key string) int {
	v := p.string(key)
	if v == "" {
		return -1
	}

	i, err := strconv.Atoi(v)
	if err != nil {
		p.errors[key] = err
	}
	return i
}