// Command uncensored-send is a small self-hosted file drop: uploads land in a flat data
// directory, expire on their own, and are served back as inert attachments.
package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"log/slog"
	"net"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"uncensored-send/internal/auth"
	"uncensored-send/internal/config"
	"uncensored-send/internal/server"
	"uncensored-send/internal/store"
)

func main() {
	if err := run(os.Args[1:]); err != nil {
		if errors.Is(err, flag.ErrHelp) {
			os.Exit(0)
		}
		fmt.Fprintln(os.Stderr, "uncensored-send: "+err.Error())
		os.Exit(1)
	}
}

func run(args []string) error {
	if len(args) > 0 && args[0] == "token" {
		return tokenCommand(args[1:])
	}
	return serve(args)
}

const serveUsage = `uncensored-send - a small self-hosted file drop

Usage:
  uncensored-send [options]                 run the server
  uncensored-send token add <name> [opts]   mint a token, printing it once
  uncensored-send token list                list tokens
  uncensored-send token rm <name>           remove a token

Options take one hyphen with a single letter (-s) and two with a full
word (--max-size). Every option can also be set from the environment.

Options:
`

func serve(args []string) error {
	var cfg config.Config
	fs := config.NewSet("uncensored-send", config.EnvPrefix)
	fs.SetOutput(os.Stderr)
	cfg.Register(fs)

	if err := fs.Parse(args); err != nil {
		if errors.Is(err, flag.ErrHelp) {
			fs.PrintUsage(os.Stdout, serveUsage)
			return flag.ErrHelp
		}
		return err
	}
	if err := cfg.Normalise(); err != nil {
		return err
	}

	setUmask()
	log := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelInfo}))

	st, err := store.Open(cfg.DataDir)
	if err != nil {
		return fmt.Errorf("opening data directory: %w", err)
	}
	defer st.Close()

	tokens, err := auth.Load(cfg.TokensPath)
	if err != nil {
		return fmt.Errorf("loading tokens: %w", err)
	}
	srv, err := server.New(&cfg, st, tokens, log)
	if err != nil {
		return err
	}

	httpSrv := &http.Server{
		Addr:    cfg.Listen,
		Handler: srv,
		// ReadTimeout and WriteTimeout are deliberately left unset: a
		// legitimate multi-gigabyte upload on a slow line would trip any value
		// large enough to be safe. Stalled connections are dropped by the
		// per-read deadline the upload handler maintains instead.
		ReadHeaderTimeout: 20 * time.Second,
		IdleTimeout:       2 * time.Minute,
		MaxHeaderBytes:    1 << 16,
		ErrorLog:          slog.NewLogLogger(log.Handler(), slog.LevelWarn),
	}

	// Bind before announcing anything: logging "listening" and only then
	// failing to bind reads as a server that started and then died.
	ln, err := net.Listen("tcp", cfg.Listen)
	if err != nil {
		return err
	}

	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()

	go sweep(ctx, st, cfg.SweepInterval, log)
	go reloadOnHUP(ctx, tokens, log)

	log.Info("listening",
		"addr", ln.Addr().String(), "data", cfg.DataDir, "base", cfg.BasePath,
		"objects", st.Count(), "stored", config.FormatBytes(st.Total()),
		"max_size", config.FormatSize(cfg.MaxSize),
		"max_expiry", config.FormatDuration(cfg.MaxExpiry))

	errc := make(chan error, 1)
	go func() {
		err := httpSrv.Serve(ln)
		if errors.Is(err, http.ErrServerClosed) {
			err = nil
		}
		errc <- err
	}()

	select {
	case err := <-errc:
		return err
	case <-ctx.Done():
		log.Info("shutting down")
		// Uploads in flight get a moment to finish; the store's own crash
		// recovery handles whatever does not.
		shutdownCtx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
		defer cancel()
		return httpSrv.Shutdown(shutdownCtx)
	}
}

// sweep removes expired objects on a timer. Reads check expiry independently,
// so this is about reclaiming disk, not about correctness.
func sweep(ctx context.Context, st *store.Store, every time.Duration, log *slog.Logger) {
	if n := st.Sweep(time.Now()); n > 0 {
		log.Info("swept expired objects", "count", n)
	}
	t := time.NewTicker(every)
	defer t.Stop()
	for {
		select {
		case <-ctx.Done():
			return
		case now := <-t.C:
			if n := st.Sweep(now); n > 0 {
				log.Info("swept expired objects", "count", n)
			}
		}
	}
}

// reloadOnHUP re-reads the token file on SIGHUP, so credentials can be changed
// without dropping uploads in flight.
func reloadOnHUP(ctx context.Context, tokens *auth.File, log *slog.Logger) {
	ch := make(chan os.Signal, 1)
	signal.Notify(ch, syscall.SIGHUP)
	defer signal.Stop(ch)
	for {
		select {
		case <-ctx.Done():
			return
		case <-ch:
			if err := tokens.Reload(); err != nil {
				log.Error("reloading tokens", "err", err)
				continue
			}
			log.Info("reloaded tokens", "count", len(tokens.List()))
		}
	}
}