// Package auth praat met de gekozen identity provider.
// Standaard is dat auth.timfalken.com (authorization-code-flow); optioneel
// Microsoft Entra ID (OIDC). E-mail komt nooit in het BlueGit-usermodel.
// Er is geen lokaal wachtwoord.
package auth

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

// Identity is het account dat een verbonden site mag zien.
type Identity struct {
	AuthID        int64
	Username      string
	AvatarURL     string
	IsAdmin       bool
	EmailVerified bool
	AccessToken   string
	ExpiresIn     int
}

// Provider is de auth-server, of een testvervanger.
// nonce is verplicht voor OIDC (Entra); TimFalken en Dev negeren hem.
// codeChallenge / codeVerifier zijn PKCE S256; verplicht bij Entra, genegeerd door TimFalken en Dev.
type Provider interface {
	AuthorizeURL(state, nonce, redirectURI, codeChallenge string) string
	Exchange(ctx context.Context, code, redirectURI, nonce, codeVerifier string) (Identity, error)
	Extend(ctx context.Context, accessToken string) (expiresIn int, err error)
	Logout(ctx context.Context, accessToken string) error
}

// TimFalken is de client voor https://auth.timfalken.com.
type TimFalken struct {
	BaseURL   string
	ClientID  string
	Secret    string
	UserAgent string
	HTTP      *http.Client
}

// NewTimFalken maakt een client. baseURL is zonder slash aan het eind.
func NewTimFalken(baseURL, clientID, secret, userAgent string) *TimFalken {
	return &TimFalken{
		BaseURL:   strings.TrimRight(baseURL, "/"),
		ClientID:  clientID,
		Secret:    secret,
		UserAgent: userAgent,
		HTTP:      &http.Client{Timeout: 15 * time.Second},
	}
}

// AuthorizeURL stuurt de browser naar de toestemmingspagina.
func (t *TimFalken) AuthorizeURL(state, nonce, redirectURI, codeChallenge string) string {
	q := url.Values{}
	q.Set("client_id", t.ClientID)
	q.Set("redirect_uri", redirectURI)
	q.Set("response_type", "code")
	q.Set("state", state)
	_ = nonce
	_ = codeChallenge
	return t.BaseURL + "/oauth/authorize?" + q.Encode()
}

// Exchange wisselt de eenmalige code om voor een bearer-token.
func (t *TimFalken) Exchange(ctx context.Context, code, redirectURI, nonce, codeVerifier string) (Identity, error) {
	_ = nonce
	_ = codeVerifier
	form := url.Values{}
	form.Set("grant_type", "authorization_code")
	form.Set("code", code)
	form.Set("redirect_uri", redirectURI)
	form.Set("client_id", t.ClientID)
	form.Set("client_secret", t.Secret)
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, t.BaseURL+"/oauth/token", 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")
	req.Header.Set("User-Agent", t.UserAgent)
	var body struct {
		AccessToken string `json:"access_token"`
		TokenType   string `json:"token_type"`
		ExpiresIn   int    `json:"expires_in"`
		Error       string `json:"error"`
		User        struct {
			ID        int64  `json:"id"`
			Username  string `json:"username"`
			AvatarURL string `json:"avatar_url"`
		} `json:"user"`
	}
	if err := t.do(req, &body); err != nil {
		return Identity{}, err
	}
	if body.Error != "" || body.AccessToken == "" || body.User.ID == 0 {
		msg := body.Error
		if msg == "" {
			msg = "lege tokenrespons"
		}
		return Identity{}, fmt.Errorf("auth: %s", msg)
	}
	id := Identity{
		AuthID:      body.User.ID,
		Username:    strings.ToLower(body.User.Username),
		AvatarURL:   body.User.AvatarURL,
		AccessToken: body.AccessToken,
		ExpiresIn:   body.ExpiresIn,
	}
	// /api/me vult is_admin en email_verified aan. Dat is admin van de
	// auth-server, niet van BlueGit.
	me, err := t.me(ctx, body.AccessToken)
	if err != nil {
		return id, nil
	}
	id.IsAdmin = me.IsAdmin
	id.EmailVerified = me.EmailVerified
	if me.Username != "" {
		id.Username = strings.ToLower(me.Username)
	}
	if me.AvatarURL != "" {
		id.AvatarURL = me.AvatarURL
	}
	return id, nil
}

type meUser struct {
	ID            int64  `json:"id"`
	Username      string `json:"username"`
	IsAdmin       bool   `json:"is_admin"`
	EmailVerified bool   `json:"email_verified"`
	AvatarURL     string `json:"avatar_url"`
}

func (t *TimFalken) me(ctx context.Context, token string) (meUser, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, t.BaseURL+"/api/me", nil)
	if err != nil {
		return meUser{}, err
	}
	t.bearer(req, token)
	var body struct {
		User  meUser `json:"user"`
		Error string `json:"error"`
	}
	if err := t.do(req, &body); err != nil {
		return meUser{}, err
	}
	if body.Error != "" {
		return meUser{}, fmt.Errorf("auth: %s", body.Error)
	}
	return body.User, nil
}

// Extend schuift de sessie een volledige dag op.
func (t *TimFalken) Extend(ctx context.Context, accessToken string) (int, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, t.BaseURL+"/api/session/extend", nil)
	if err != nil {
		return 0, err
	}
	t.bearer(req, accessToken)
	var body struct {
		ExpiresIn int    `json:"expires_in"`
		Error     string `json:"error"`
	}
	if err := t.do(req, &body); err != nil {
		return 0, err
	}
	if body.Error != "" {
		return 0, fmt.Errorf("auth: %s", body.Error)
	}
	if body.ExpiresIn <= 0 {
		body.ExpiresIn = 86400
	}
	return body.ExpiresIn, nil
}

// Logout trekt het bearer-token in.
func (t *TimFalken) Logout(ctx context.Context, accessToken string) error {
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, t.BaseURL+"/api/logout", nil)
	if err != nil {
		return err
	}
	t.bearer(req, accessToken)
	var body struct {
		Error string `json:"error"`
	}
	if err := t.do(req, &body); err != nil {
		return err
	}
	if body.Error != "" {
		return fmt.Errorf("auth: %s", body.Error)
	}
	return nil
}

func (t *TimFalken) bearer(req *http.Request, token string) {
	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("Accept", "application/json")
	req.Header.Set("User-Agent", t.UserAgent)
}

func (t *TimFalken) do(req *http.Request, dest any) error {
	res, err := t.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"`
		}
		_ = json.Unmarshal(raw, &env)
		if env.Error == "" {
			env.Error = res.Status
		}
		return fmt.Errorf("auth: %s", env.Error)
	}
	if dest == nil {
		return nil
	}
	if err := json.Unmarshal(raw, dest); err != nil {
		return fmt.Errorf("auth-antwoord: %w", err)
	}
	return nil
}
