package auth

import (
	"context"
	"crypto/sha256"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strings"
	"sync"
	"time"

	"gitlab.com/Timfa/bluegit/internal/names"
)

// entraScope is wat de authorization-code-flow bij Entra vraagt.
const entraScope = "openid profile email User.Read"

// idTokenSkew is de toegestane klokverschuiving bij exp, nbf en iat.
const idTokenSkew = 60 * time.Second

// Entra is Microsoft Entra ID (OIDC, één tenant).
// Extend en Logout doen niets op afstand: Entra kent die TimFalken-API's niet.
type Entra struct {
	Issuer    string
	TenantID  string
	ClientID  string
	Secret    string
	UserAgent string
	HTTP      *http.Client
	// GraphPhotoURL overschrijft de foto-URL van Microsoft Graph (tests).
	GraphPhotoURL string

	mu      sync.Mutex
	authz   string
	token   string
	jwks    *jwksCache
	jwksURI string
}

// NewEntra maakt een OIDC-client. issuer is zonder slash aan het eind
// (standaard https://login.microsoftonline.com/{tenant}/v2.0).
func NewEntra(issuer, tenantID, clientID, secret, userAgent string) *Entra {
	return &Entra{
		Issuer:    strings.TrimRight(issuer, "/"),
		TenantID:  tenantID,
		ClientID:  clientID,
		Secret:    secret,
		UserAgent: userAgent,
		HTTP:      &http.Client{Timeout: 15 * time.Second},
		jwks:      &jwksCache{},
	}
}

// AuthorizeURL stuurt de browser naar Entra met openid, profile, email en User.Read, nonce en PKCE S256.
func (e *Entra) AuthorizeURL(state, nonce, redirectURI, codeChallenge string) string {
	authz, err := e.authorizeEndpoint(context.Background())
	if err != nil {
		// Zonder discovery: vaste Entra-URL zodat /login niet paniceert.
		authz = strings.TrimSuffix(e.Issuer, "/v2.0") + "/oauth2/v2.0/authorize"
	}
	q := url.Values{}
	q.Set("client_id", e.ClientID)
	q.Set("redirect_uri", redirectURI)
	q.Set("response_type", "code")
	q.Set("response_mode", "query")
	q.Set("scope", entraScope)
	q.Set("state", state)
	q.Set("nonce", nonce)
	if codeChallenge != "" {
		q.Set("code_challenge", codeChallenge)
		q.Set("code_challenge_method", "S256")
	}
	return authz + "?" + q.Encode()
}

// Exchange wisselt de code om, valideert het ID-token (JWKS, iss, aud, exp, tid, nonce, PKCE)
// en mapt oid/tid naar een BlueGit-identity.
func (e *Entra) Exchange(ctx context.Context, code, redirectURI, nonce, codeVerifier string) (Identity, error) {
	if nonce == "" {
		return Identity{}, fmt.Errorf("auth: nonce ontbreekt")
	}
	if strings.TrimSpace(codeVerifier) == "" {
		return Identity{}, fmt.Errorf("auth: PKCE-verifier ontbreekt")
	}
	tokenURL, err := e.tokenEndpoint(ctx)
	if err != nil {
		return Identity{}, err
	}
	form := url.Values{}
	form.Set("grant_type", "authorization_code")
	form.Set("code", code)
	form.Set("redirect_uri", redirectURI)
	form.Set("client_id", e.ClientID)
	form.Set("client_secret", e.Secret)
	form.Set("scope", entraScope)
	form.Set("code_verifier", codeVerifier)
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, tokenURL, strings.NewReader(form.Encode()))
	if err != nil {
		return Identity{}, err
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.Header.Set("Accept", "application/json")
	if e.UserAgent != "" {
		req.Header.Set("User-Agent", e.UserAgent)
	}
	var body struct {
		AccessToken string `json:"access_token"`
		IDToken     string `json:"id_token"`
		ExpiresIn   int    `json:"expires_in"`
		Error       string `json:"error"`
		ErrorDesc   string `json:"error_description"`
	}
	if err := e.doJSON(req, &body); err != nil {
		return Identity{}, err
	}
	if body.Error != "" || body.IDToken == "" {
		msg := body.Error
		if body.ErrorDesc != "" {
			msg = body.ErrorDesc
		}
		if msg == "" {
			msg = "lege tokenrespons"
		}
		return Identity{}, fmt.Errorf("auth: %s", msg)
	}
	claims, err := e.verifyIDToken(ctx, body.IDToken, nonce)
	if err != nil {
		return Identity{}, err
	}
	oid := claims.OID
	if oid == "" {
		oid = claims.Sub
	}
	if oid == "" {
		return Identity{}, fmt.Errorf("auth: id_token zonder oid/sub")
	}
	username, err := entraUsername(claims.PreferredUsername, claims.Email, claims.Name, oid)
	if err != nil {
		return Identity{}, err
	}
	return Identity{
		AuthID:      StableAuthID(e.TenantID, oid),
		Username:    username,
		AvatarURL:   "", // Entra levert geen avatar-URL zonder Graph-foto-API.
		IsAdmin:     false,
		AccessToken: body.AccessToken,
		ExpiresIn:   86400, // BlueGit-sessie; Entra's access_token is korter.
	}, nil
}

// Extend verlengt alleen lokaal: Entra heeft geen /api/session/extend.
func (e *Entra) Extend(ctx context.Context, accessToken string) (int, error) {
	return 86400, nil
}

// Logout doet niets op afstand; BlueGit wist de lokale sessie zelf.
func (e *Entra) Logout(ctx context.Context, accessToken string) error {
	return nil
}

type idClaims struct {
	Iss               string       `json:"iss"`
	Aud               jsonAudience `json:"aud"`
	Exp               int64        `json:"exp"`
	Iat               int64        `json:"iat"`
	Nbf               int64        `json:"nbf"`
	Nonce             string       `json:"nonce"`
	OID               string       `json:"oid"`
	Sub               string       `json:"sub"`
	TID               string       `json:"tid"`
	PreferredUsername string       `json:"preferred_username"`
	Email             string       `json:"email"`
	Name              string       `json:"name"`
}

func (e *Entra) verifyIDToken(ctx context.Context, raw, nonce string) (idClaims, error) {
	hdr, payload, err := parseJWT(raw)
	if err != nil {
		return idClaims{}, err
	}
	var claims idClaims
	if hdr.Alg != "RS256" {
		return idClaims{}, fmt.Errorf("auth: onverwacht jwt-algorithme %q", hdr.Alg)
	}
	if err := json.Unmarshal(payload, &claims); err != nil {
		return idClaims{}, fmt.Errorf("auth: id_token claims: %w", err)
	}
	if claims.Iss != e.Issuer {
		return idClaims{}, fmt.Errorf("auth: ongeldige issuer")
	}
	if !claims.Aud.includes(e.ClientID) {
		return idClaims{}, fmt.Errorf("auth: ongeldige audience")
	}
	now := time.Now()
	if claims.Exp == 0 || now.Add(-idTokenSkew).Unix() >= claims.Exp {
		return idClaims{}, fmt.Errorf("auth: id_token verlopen of mist exp")
	}
	if claims.Nbf > 0 && now.Add(idTokenSkew).Unix() < claims.Nbf {
		return idClaims{}, fmt.Errorf("auth: id_token nog niet geldig")
	}
	if claims.Iat > 0 && now.Add(idTokenSkew).Unix() < claims.Iat {
		return idClaims{}, fmt.Errorf("auth: id_token iat ligt in de toekomst")
	}
	if claims.Nonce == "" || claims.Nonce != nonce {
		return idClaims{}, fmt.Errorf("auth: ongeldige nonce")
	}
	if claims.TID == "" || !strings.EqualFold(claims.TID, e.TenantID) {
		return idClaims{}, fmt.Errorf("auth: onverwachte tenant")
	}
	key, err := e.signingKey(ctx, hdr.Kid)
	if err != nil {
		return idClaims{}, err
	}
	if err := verifyRS256(raw, key); err != nil {
		return idClaims{}, err
	}
	return claims, nil
}

func (e *Entra) signingKey(ctx context.Context, kid string) (any, error) {
	if err := e.ensureDiscovery(ctx); err != nil {
		return nil, err
	}
	return e.jwks.key(ctx, e.HTTP, e.jwksURI, kid)
}

func (e *Entra) authorizeEndpoint(ctx context.Context) (string, error) {
	if err := e.ensureDiscovery(ctx); err != nil {
		return "", err
	}
	e.mu.Lock()
	defer e.mu.Unlock()
	return e.authz, nil
}

func (e *Entra) tokenEndpoint(ctx context.Context) (string, error) {
	if err := e.ensureDiscovery(ctx); err != nil {
		return "", err
	}
	e.mu.Lock()
	defer e.mu.Unlock()
	return e.token, nil
}

func (e *Entra) ensureDiscovery(ctx context.Context) error {
	e.mu.Lock()
	if e.authz != "" && e.token != "" && e.jwksURI != "" {
		e.mu.Unlock()
		return nil
	}
	e.mu.Unlock()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, e.Issuer+"/.well-known/openid-configuration", nil)
	if err != nil {
		return err
	}
	if e.UserAgent != "" {
		req.Header.Set("User-Agent", e.UserAgent)
	}
	var doc struct {
		AuthorizationEndpoint string `json:"authorization_endpoint"`
		TokenEndpoint         string `json:"token_endpoint"`
		JWKSURI               string `json:"jwks_uri"`
		Issuer                string `json:"issuer"`
	}
	if err := e.doJSON(req, &doc); err != nil {
		return fmt.Errorf("auth: oidc discovery: %w", err)
	}
	if doc.AuthorizationEndpoint == "" || doc.TokenEndpoint == "" || doc.JWKSURI == "" {
		return fmt.Errorf("auth: onvolledige oidc discovery")
	}
	if doc.Issuer != "" && doc.Issuer != e.Issuer {
		return fmt.Errorf("auth: discovery-issuer wijkt af")
	}
	for _, ep := range []string{doc.AuthorizationEndpoint, doc.TokenEndpoint, doc.JWKSURI} {
		if err := oidcEndpointHostOK(ep, e.Issuer); err != nil {
			return err
		}
	}
	e.mu.Lock()
	e.authz = doc.AuthorizationEndpoint
	e.token = doc.TokenEndpoint
	e.jwksURI = doc.JWKSURI
	e.mu.Unlock()
	return nil
}

// oidcEndpointHostOK eist dat authorization, token en jwks op dezelfde host
// staan als de issuer, en HTTPS gebruiken als de issuer HTTPS is.
func oidcEndpointHostOK(endpoint, issuer string) error {
	eu, err := url.Parse(endpoint)
	if err != nil || eu.Host == "" || (eu.Scheme != "https" && eu.Scheme != "http") {
		return fmt.Errorf("auth: ongeldig OIDC-eindpunt %q", endpoint)
	}
	iu, err := url.Parse(issuer)
	if err != nil || iu.Host == "" {
		return fmt.Errorf("auth: ongeldige issuer %q", issuer)
	}
	if !strings.EqualFold(eu.Hostname(), iu.Hostname()) {
		return fmt.Errorf("auth: OIDC-eindpunt host %s past niet bij issuer-host %s", eu.Hostname(), iu.Hostname())
	}
	if iu.Scheme == "https" && eu.Scheme != "https" {
		return fmt.Errorf("auth: OIDC-eindpunt moet HTTPS zijn: %s", endpoint)
	}
	return nil
}

func (e *Entra) doJSON(req *http.Request, dest any) error {
	res, err := e.HTTP.Do(req)
	if err != nil {
		return fmt.Errorf("auth: %w", err)
	}
	defer res.Body.Close()
	raw, err := io.ReadAll(io.LimitReader(res.Body, 1<<20))
	if err != nil {
		return err
	}
	if res.StatusCode >= 400 {
		var env struct {
			Error     string `json:"error"`
			ErrorDesc string `json:"error_description"`
		}
		_ = json.Unmarshal(raw, &env)
		msg := env.ErrorDesc
		if msg == "" {
			msg = env.Error
		}
		if msg == "" {
			msg = res.Status
		}
		return fmt.Errorf("auth: %s", msg)
	}
	if dest == nil {
		return nil
	}
	if err := json.Unmarshal(raw, dest); err != nil {
		return fmt.Errorf("auth-antwoord: %w", err)
	}
	return nil
}

// StableAuthID maakt een positieve int64 uit tenant + object-id.
// Collisie is theoretisch mogelijk; bij een botsing krijgt de tweede gebruiker
// dezelfde auth_id (upsert op bestaande rij).
func StableAuthID(tenantID, objectID string) int64 {
	sum := sha256.Sum256([]byte(tenantID + "\x00" + objectID))
	var n uint64
	for i := 0; i < 8; i++ {
		n = n<<8 | uint64(sum[i])
	}
	n &^= 1 << 63
	if n == 0 {
		n = 1
	}
	return int64(n)
}

// entraUsername maakt een BlueGit-gebruikersnaam uit Entra-claims.
func entraUsername(preferred, email, display, oid string) (string, error) {
	raw := strings.TrimSpace(preferred)
	if raw == "" {
		raw = strings.TrimSpace(email)
	}
	if i := strings.IndexByte(raw, '@'); i > 0 {
		raw = raw[:i]
	}
	if raw == "" {
		raw = strings.TrimSpace(display)
	}
	s := sanitizeUsername(raw)
	if s == "" || names.ValidUsername(s) != nil {
		sum := sha256.Sum256([]byte(oid))
		s = fmt.Sprintf("u%x", sum[:4])
	}
	if err := names.ValidUsername(s); err != nil {
		return "", fmt.Errorf("auth: geen bruikbare gebruikersnaam")
	}
	return s, nil
}

func sanitizeUsername(raw string) string {
	s := strings.ToLower(strings.TrimSpace(raw))
	var b strings.Builder
	for _, r := range s {
		switch {
		case r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '_', r == '-':
			b.WriteRune(r)
		case r == '.' || r == ' ':
			b.WriteByte('-')
		}
	}
	out := strings.Trim(b.String(), "-_")
	for strings.Contains(out, "--") {
		out = strings.ReplaceAll(out, "--", "-")
	}
	if len(out) > 63 {
		out = strings.Trim(out[:63], "-_")
	}
	return out
}
