// 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"
	"net/url"
	"os"
	"os/signal"
	"strings"
	"syscall"
	"time"

	"gitlab.com/Timfa/bluegit/internal/apppaths"
	"gitlab.com/Timfa/bluegit/internal/backupserver/config"
	"gitlab.com/Timfa/bluegit/internal/backupserver/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 config  [--config …]     instellingen tonen
  bluegit-backup set     [--config …] sleutel=waarde …   instellingen wijzigen
  bluegit-backup delete  [--config …] ARCHIEF
  bluegit-backup rollback [--config …] ARCHIEF   (vraagt om de naam over te typen)
  bluegit-backup disconnect [--config …]
  bluegit-backup actions [--config …]     alle API-acties
  bluegit-backup token   [--config …]     het beheertoken voor de webinterface
  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 "config":
		err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/config")
	case "set":
		err = setConfig(os.Args[2:])
	case "disconnect":
		err = simple(os.Args[2:], http.MethodPost, "/api/v1/admin/disconnect")
	case "delete":
		err = withName(os.Args[2:], func(c *client, name string) (int, []byte, error) {
			return c.do(http.MethodDelete, "/api/v1/admin/archives/"+url.PathEscape(name), nil)
		})
	case "rollback":
		err = rollback(os.Args[2:], os.Stdin, os.Stdout)
	case "actions":
		err = simple(os.Args[2:], http.MethodGet, "/api/v1/admin/actions")
	case "token":
		err = printToken(os.Args[2:])
	case "example-config":
		fmt.Print(config.Example())
	case "version", "--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 {
	return apppaths.ConfigFile(p, "BLUEGIT_BACKUP_CONFIG", "bluegit-backup.yml", "/etc/bluegit-backup/config.yml", "BlueGit-backup")
}

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()
	cfg = srv.Cfg // met settings.yml
	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
	}
	if set, err := config.LoadSettings(cfg.DataDir); err == nil {
		_ = cfg.Apply(set)
	}
	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 printResult(code int, b []byte) error {
	var pretty bytes.Buffer
	if json.Indent(&pretty, b, "", "  ") == nil {
		b = pretty.Bytes()
	}
	fmt.Println(strings.TrimSpace(string(b)))
	if code >= 300 {
		return fmt.Errorf("HTTP %d", code)
	}
	return nil
}

func setConfig(args []string) error {
	fs := flag.NewFlagSet("set", flag.ExitOnError)
	cfgPath := fs.String("config", "", "pad naar config.yml")
	_ = fs.Parse(args)
	set := map[string]string{}
	for _, kv := range fs.Args() {
		k, v, ok := strings.Cut(kv, "=")
		if !ok {
			return fmt.Errorf("verwacht sleutel=waarde, kreeg %q", kv)
		}
		set[k] = v
	}
	if len(set) == 0 {
		return fmt.Errorf("geef minstens één sleutel=waarde")
	}
	c, err := newClient(*cfgPath)
	if err != nil {
		return err
	}
	code, b, err := c.do(http.MethodPut, "/api/v1/admin/config", set)
	if err != nil {
		return err
	}
	return printResult(code, b)
}

func withName(args []string, f func(c *client, name string) (int, []byte, error)) error {
	fs := flag.NewFlagSet("cmd", flag.ExitOnError)
	cfgPath := fs.String("config", "", "pad naar config.yml")
	_ = fs.Parse(args)
	if fs.NArg() != 1 {
		return fmt.Errorf("geef precies één archiefnaam")
	}
	c, err := newClient(*cfgPath)
	if err != nil {
		return err
	}
	code, b, err := f(c, fs.Arg(0))
	if err != nil {
		return err
	}
	return printResult(code, b)
}

func rollback(args []string, stdin io.Reader, stdout io.Writer) error {
	return withName(args, func(c *client, name string) (int, []byte, error) {
		fmt.Fprintln(stdout, "LET OP: een rollback vervangt alle gegevens van BlueGit door dit archief en kan niet ongedaan worden gemaakt.")
		fmt.Fprint(stdout, "Typ de archiefnaam over om door te gaan: ")
		line, _ := bufio.NewReader(stdin).ReadString('\n')
		if strings.TrimSpace(line) != name {
			return 0, nil, fmt.Errorf("afgebroken; er is niets veranderd")
		}
		return c.do(http.MethodPost, "/api/v1/admin/rollback", map[string]string{"archive": name, "confirm": name})
	})
}

func printToken(args []string) error {
	fs := flag.NewFlagSet("token", flag.ExitOnError)
	cfgPath := fs.String("config", "", "pad naar config.yml")
	_ = fs.Parse(args)
	cfg, err := config.Load(configPath(*cfgPath))
	if err != nil {
		return err
	}
	tok, err := server.ReadAdminToken(cfg.DataDir)
	if err != nil {
		return fmt.Errorf("admin.token niet leesbaar (start de server eerst, en draai als de gebruiker bluegit-backup): %w", err)
	}
	fmt.Println(tok)
	return 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
}
