// bluegit-backup houdt een kopie bij van één BlueGit-instantie.
package main

import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log/slog"
	"net"
	"net/http"
	"os"
	"os/signal"
	"strings"
	"syscall"
	"time"

	"git.timfalken.com/timfa/bluegit-backup/internal/config"
	"git.timfalken.com/timfa/bluegit-backup/internal/server"
)

func usage() {
	fmt.Fprint(os.Stderr, `bluegit-backup

  bluegit-backup serve   [--config /etc/bluegit-backup/config.yml]
  bluegit-backup connect [--config …] --url https://git.example.com [--key bgbk_…] [--on-conflict wipe|restore]
  bluegit-backup status  [--config …]
  bluegit-backup list    [--config …]
  bluegit-backup archive [--config …]     nu een archief maken
  bluegit-backup sync    [--config …]     nu synchroniseren
  bluegit-backup prune   [--config …]     bewaarregels nu toepassen
  bluegit-backup example-config
  bluegit-backup version

De key kan ook uit BLUEGIT_BACKUP_KEY komen (dan staat hij niet in de proceslijst).
`)
}

func main() {
	if len(os.Args) < 2 {
		usage()
		os.Exit(2)
	}
	var err error
	switch os.Args[1] {
	case "serve":
		err = serve(os.Args[2:])
	case "connect":
		err = connect(os.Args[2:], os.Stdin, os.Stdout)
	case "status":
		err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/status")
	case "list":
		err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/archives")
	case "archive":
		err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/archive")
	case "sync":
		err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/sync")
	case "prune":
		err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/prune")
	case "example-config":
		fmt.Print(config.Example())
	case "version":
		fmt.Println(server.Version)
	default:
		usage()
		os.Exit(2)
	}
	if err != nil {
		fmt.Fprintln(os.Stderr, "bluegit-backup:", err)
		os.Exit(1)
	}
}

func configPath(p string) string {
	if p != "" {
		return p
	}
	if v := os.Getenv("BLUEGIT_BACKUP_CONFIG"); v != "" {
		return v
	}
	if _, err := os.Stat("bluegit-backup.yml"); err == nil {
		return "bluegit-backup.yml"
	}
	return "/etc/bluegit-backup/config.yml"
}

func serve(args []string) error {
	fs := flag.NewFlagSet("serve", flag.ExitOnError)
	cfgPath := fs.String("config", "", "pad naar config.yml")
	_ = fs.Parse(args)
	cfg, err := config.Load(configPath(*cfgPath))
	if err != nil {
		return err
	}
	log := slog.New(slog.NewTextHandler(os.Stdout, nil))
	srv, err := server.New(cfg, log)
	if err != nil {
		return err
	}
	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()
	ln, err := net.Listen("tcp", cfg.Listen)
	if err != nil {
		return err
	}
	hs := &http.Server{Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}
	go func() {
		<-ctx.Done()
		c, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer cancel()
		_ = hs.Shutdown(c)
	}()
	srv.Run(ctx)
	log.Info("bluegit-backup luistert", "addr", ln.Addr().String(), "public_url", cfg.PublicURL, "version", server.Version)
	if err := hs.Serve(ln); err != nil && err != http.ErrServerClosed {
		return err
	}
	return nil
}

type client struct {
	base, token string
}

func newClient(cfgPath string) (*client, error) {
	cfg, err := config.Load(configPath(cfgPath))
	if err != nil {
		return nil, err
	}
	tok, err := server.ReadAdminToken(cfg.DataDir)
	if err != nil {
		return nil, fmt.Errorf("admin.token lezen (draai als de gebruiker van de dienst of root): %w", err)
	}
	host, port, err := net.SplitHostPort(cfg.Listen)
	if err != nil {
		return nil, err
	}
	if host == "" || host == "0.0.0.0" || host == "::" {
		host = "127.0.0.1"
	}
	return &client{base: "http://" + net.JoinHostPort(host, port), token: tok}, nil
}

func (c *client) do(method, p string, in any) (int, []byte, error) {
	var body io.Reader
	if in != nil {
		b, _ := json.Marshal(in)
		body = bytes.NewReader(b)
	}
	req, _ := http.NewRequest(method, c.base+p, body)
	req.Header.Set("Authorization", "Bearer "+c.token)
	req.Header.Set("Content-Type", "application/json")
	resp, err := (&http.Client{Timeout: 30 * time.Minute}).Do(req)
	if err != nil {
		return 0, nil, err
	}
	defer resp.Body.Close()
	b, _ := io.ReadAll(resp.Body)
	return resp.StatusCode, b, nil
}

func simple(args []string, method, p string) error {
	fs := flag.NewFlagSet("cmd", flag.ExitOnError)
	cfgPath := fs.String("config", "", "pad naar config.yml")
	_ = fs.Parse(args)
	c, err := newClient(*cfgPath)
	if err != nil {
		return err
	}
	code, b, err := c.do(method, p, nil)
	if err != nil {
		return err
	}
	var pretty bytes.Buffer
	if json.Indent(&pretty, b, "", "  ") == nil {
		b = pretty.Bytes()
	}
	fmt.Println(string(b))
	if code >= 300 {
		return fmt.Errorf("HTTP %d", code)
	}
	return nil
}

func connect(args []string, stdin io.Reader, stdout io.Writer) error {
	fs := flag.NewFlagSet("connect", flag.ExitOnError)
	cfgPath := fs.String("config", "", "pad naar config.yml")
	u := fs.String("url", "", "adres van BlueGit")
	key := fs.String("key", "", "Backupserver-Key (of BLUEGIT_BACKUP_KEY)")
	onConflict := fs.String("on-conflict", "", "wipe of restore, zonder te vragen")
	_ = fs.Parse(args)
	if *key == "" {
		*key = os.Getenv("BLUEGIT_BACKUP_KEY")
	}
	if *u == "" || *key == "" {
		return fmt.Errorf("--url en --key (of BLUEGIT_BACKUP_KEY) zijn nodig")
	}
	c, err := newClient(*cfgPath)
	if err != nil {
		return err
	}
	req := server.ConnectRequest{URL: *u, Key: *key, OnConflict: *onConflict}
	code, b, err := c.do(http.MethodPost, "/api/v1/admin/connect", req)
	if err != nil {
		return err
	}
	if code == http.StatusConflict {
		var cf server.ConflictError
		_ = json.Unmarshal(b, &cf)
		fmt.Fprintf(stdout, "Deze backup server hoort bij een andere BlueGit (%s, instance %s) en heeft %d archief/archieven.\n", cf.PreviousURL, cf.PreviousInstance, cf.Archives)
		fmt.Fprintln(stdout, "Een backup server kan maar aan één BlueGit gekoppeld zijn. Kies:")
		fmt.Fprintln(stdout, "  1) Oude backups verwijderen en met de nieuwe instantie verbinden")
		fmt.Fprintln(stdout, "  2) De nieuwe instantie terugzetten naar de gegevens in deze backup server (overschrijft alles daar)")
		fmt.Fprint(stdout, "Keuze [1/2, leeg = afbreken]: ")
		line, _ := bufio.NewReader(stdin).ReadString('\n')
		switch strings.TrimSpace(line) {
		case "1":
			req.OnConflict = "wipe"
		case "2":
			req.OnConflict = "restore"
		default:
			return fmt.Errorf("afgebroken; er is niets veranderd")
		}
		code, b, err = c.do(http.MethodPost, "/api/v1/admin/connect", req)
		if err != nil {
			return err
		}
	}
	fmt.Fprintln(stdout, strings.TrimSpace(string(b)))
	if code >= 300 {
		return fmt.Errorf("HTTP %d", code)
	}
	return nil
}
