// Package mirror houdt de draaiende kopie van één BlueGit bij.
package mirror

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

	"git.timfalken.com/timfa/bluegit-backup/internal/protocol"
	"git.timfalken.com/timfa/bluegit-backup/internal/throttle"
)

// ErrGone betekent dat een bestand tussen manifest en download verdween.
var ErrGone = errors.New("bestand verdwenen")

// Remote is de backup-API van één BlueGit, met de Backupserver-Key.
type Remote struct {
	URL     string
	Key     string
	HTTP    *http.Client
	Limiter *throttle.Limiter
}

func (r *Remote) client() *http.Client {
	if r.HTTP != nil {
		return r.HTTP
	}
	return &http.Client{Timeout: 0}
}

func (r *Remote) req(ctx context.Context, method, p string, body io.Reader) (*http.Response, error) {
	req, err := http.NewRequestWithContext(ctx, method, strings.TrimRight(r.URL, "/")+p, body)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Authorization", "Bearer "+r.Key)
	req.Header.Set("User-Agent", "bluegit-backup")
	resp, err := r.client().Do(req)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode >= 300 {
		defer resp.Body.Close()
		raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))
		var e struct {
			Error string `json:"error"`
		}
		_ = json.Unmarshal(raw, &e)
		if e.Error == "" {
			e.Error = strings.TrimSpace(string(raw))
		}
		if resp.StatusCode == http.StatusNotFound && strings.HasPrefix(p, "/api/v1/backup/file") {
			return nil, ErrGone
		}
		return nil, &HTTPError{Status: resp.StatusCode, Msg: e.Error}
	}
	return resp, nil
}

// HTTPError is een foutantwoord van BlueGit.
type HTTPError struct {
	Status int
	Msg    string
}

func (e *HTTPError) Error() string { return fmt.Sprintf("BlueGit HTTP %d: %s", e.Status, e.Msg) }

func (r *Remote) getJSON(ctx context.Context, p string, out any) error {
	resp, err := r.req(ctx, http.MethodGet, p, nil)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	return json.NewDecoder(resp.Body).Decode(out)
}

// Info vraagt het instance-id op en controleert zo ook de key.
func (r *Remote) Info(ctx context.Context) (protocol.Info, error) {
	var out protocol.Info
	err := r.getJSON(ctx, "/api/v1/backup/info", &out)
	return out, err
}

// Connect vertelt BlueGit waar deze server bereikbaar is.
func (r *Remote) Connect(ctx context.Context, publicURL, serverID string) error {
	b, _ := json.Marshal(map[string]string{"server_url": publicURL, "server_id": serverID})
	resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/connect", bytes.NewReader(b))
	if err != nil {
		return err
	}
	resp.Body.Close()
	return nil
}

// Manifest vraagt de volledige lijst op. BlueGit maakt daarbij een nieuwe
// databasekopie.
func (r *Remote) Manifest(ctx context.Context) (protocol.Manifest, error) {
	var out protocol.Manifest
	err := r.getJSON(ctx, "/api/v1/backup/manifest", &out)
	return out, err
}

// Fetch opent één bestand, begrensd door de limiter.
func (r *Remote) Fetch(ctx context.Context, logical string) (io.ReadCloser, error) {
	resp, err := r.req(ctx, http.MethodGet, "/api/v1/backup/file?path="+url.QueryEscape(logical), nil)
	if err != nil {
		return nil, err
	}
	return struct {
		io.Reader
		io.Closer
	}{r.Limiter.Reader(ctx, resp.Body), resp.Body}, nil
}

// Restore stuurt een tar.gz naar BlueGit. BlueGit herstart daarna.
func (r *Remote) Restore(ctx context.Context, body io.Reader) error {
	resp, err := r.req(ctx, http.MethodPost, "/api/v1/backup/restore", body)
	if err != nil {
		return err
	}
	resp.Body.Close()
	return nil
}

// WaitUp wacht tot BlueGit na een herstart weer antwoordt.
func (r *Remote) WaitUp(ctx context.Context, timeout time.Duration) error {
	deadline := time.Now().Add(timeout)
	// Eerst kort wachten: BlueGit herstart pas na zijn 202.
	time.Sleep(500 * time.Millisecond)
	for {
		c, cancel := context.WithTimeout(ctx, 3*time.Second)
		_, err := r.Info(c)
		cancel()
		if err == nil {
			return nil
		}
		if time.Now().After(deadline) {
			return fmt.Errorf("BlueGit kwam niet terug: %w", err)
		}
		select {
		case <-ctx.Done():
			return ctx.Err()
		case <-time.After(300 * time.Millisecond):
		}
	}
}
