package backup

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"sync"
	"time"
)

// Archive is één archief zoals de backup server het meldt.
type Archive struct {
	Name      string    `json:"name"`
	CreatedAt time.Time `json:"created_at"`
	Size      int64     `json:"size"`
}

// RemoteStatus is wat de backup server over zichzelf zegt.
type RemoteStatus struct {
	Version   string    `json:"version"`
	LastSync  time.Time `json:"last_sync"`
	SyncError string    `json:"sync_error,omitempty"`
	Rollback  struct {
		State   string    `json:"state"`
		Archive string    `json:"archive,omitempty"`
		Error   string    `json:"error,omitempty"`
		At      time.Time `json:"at,omitempty"`
	} `json:"rollback"`
	Interval      string `json:"archive_interval"`
	RetentionDays int    `json:"retention_days"`
}

// Client praat ondertekend met de gekoppelde backup server.
type Client struct {
	Manager *Manager
	HTTP    *http.Client
	Now     func() time.Time
}

func (c *Client) do(ctx context.Context, method, p string, in, out any) error {
	conn, err := c.Manager.Load()
	if err != nil {
		return err
	}
	if !conn.Connected() {
		return fmt.Errorf("geen backup server gekoppeld")
	}
	inst, err := c.Manager.InstanceID()
	if err != nil {
		return err
	}
	var body []byte
	if in != nil {
		if body, err = json.Marshal(in); err != nil {
			return err
		}
	}
	req, err := http.NewRequestWithContext(ctx, method, conn.ServerURL+p, bytes.NewReader(body))
	if err != nil {
		return err
	}
	if in != nil {
		req.Header.Set("Content-Type", "application/json")
	}
	now := time.Now
	if c.Now != nil {
		now = c.Now
	}
	Sign(req, conn.SignSecret, inst, body, now())
	hc := c.HTTP
	if hc == nil {
		hc = &http.Client{Timeout: 15 * time.Second}
	}
	resp, err := hc.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	raw, _ := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
	if resp.StatusCode >= 300 {
		var e struct {
			Error string `json:"error"`
		}
		_ = json.Unmarshal(raw, &e)
		if e.Error == "" {
			e.Error = resp.Status
		}
		return fmt.Errorf("backup server: %s", e.Error)
	}
	if out != nil {
		return json.Unmarshal(raw, out)
	}
	return nil
}

// Archives vraagt de lijst met archieven op, nieuwste eerst.
func (c *Client) Archives(ctx context.Context) ([]Archive, error) {
	var out struct {
		Archives []Archive `json:"archives"`
	}
	err := c.do(ctx, http.MethodGet, "/api/v1/archives", nil, &out)
	return out.Archives, err
}

// Status vraagt de toestand van de backup server op.
func (c *Client) Status(ctx context.Context) (RemoteStatus, error) {
	var out RemoteStatus
	err := c.do(ctx, http.MethodGet, "/api/v1/status", nil, &out)
	return out, err
}

// Rollback vraagt de backup server om archive terug te zetten. De server
// antwoordt meteen; het terugsturen naar BlueGit gebeurt daarna.
func (c *Client) Rollback(ctx context.Context, archive string) error {
	return c.do(ctx, http.MethodPost, "/api/v1/rollback", map[string]string{"archive": archive}, nil)
}

// Notify meldt dat er iets veranderd is.
func (c *Client) Notify(ctx context.Context) error {
	return c.do(ctx, http.MethodPost, "/api/v1/notify", map[string]any{"at": time.Now().UTC()}, nil)
}

// Notifier bundelt wijzigingen: hoogstens één melding per Delay, en bij een
// mislukking een paar nieuwe pogingen. De backup server haalt daarnaast
// periodiek alles op, dus een gemiste melding kost alleen vertraging.
type Notifier struct {
	Client *Client
	Delay  time.Duration
	once   sync.Once
	kick   chan struct{}
}

// Changed zegt dat er iets veranderd is. Blokkeert nooit.
func (n *Notifier) Changed() {
	if n == nil {
		return
	}
	n.once.Do(func() {
		n.kick = make(chan struct{}, 1)
		go n.loop()
	})
	select {
	case n.kick <- struct{}{}:
	default:
	}
}

func (n *Notifier) loop() {
	delay := n.Delay
	if delay <= 0 {
		delay = 2 * time.Second
	}
	for range n.kick {
		time.Sleep(delay)
		// Wat in de tussentijd binnenkwam, zit in deze melding.
		select {
		case <-n.kick:
		default:
		}
		conn, err := n.Client.Manager.Load()
		if err != nil || !conn.Connected() {
			continue
		}
		for try := 0; try < 4; try++ {
			ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
			err := n.Client.Notify(ctx)
			cancel()
			if err == nil {
				break
			}
			time.Sleep(time.Duration(1<<try) * 2 * time.Second)
		}
	}
}
