// Command notas roda o servidor web de notas estilo Mousepad.
//
// Configuração por variáveis de ambiente:
//
//	NOTES_TOKEN     token de acesso (obrigatório)
//	NOTES_DATA_DIR  diretório de dados (padrão ./data)
//	NOTES_ADDR      endereço de escuta (padrão :8080)
package main

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

	"github.com/lgcosta/notas-online/internal/api"
	"github.com/lgcosta/notas-online/internal/store"
	"github.com/lgcosta/notas-online/web"
)

func main() {
	if err := run(); err != nil {
		slog.Error("fatal", "err", err)
		os.Exit(1)
	}
}

func run() error {
	addr := flag.String("addr", envOr("NOTES_ADDR", ":8080"), "endereço de escuta")
	dataDir := flag.String("data", envOr("NOTES_DATA_DIR", "./data"), "diretório de dados")
	flag.Parse()

	token := os.Getenv("NOTES_TOKEN")
	if token == "" {
		return errors.New("NOTES_TOKEN não definido — defina o token de acesso " +
			"(ex.: NOTES_TOKEN=$(openssl rand -hex 24) docker compose up -d)")
	}
	// Secure no cookie só é decidido por configuração explícita: X-Forwarded-Proto
	// do cliente é spoofável. Ative quando o acesso é sempre por HTTPS (proxy).
	secureCookie := envOr("NOTES_SECURE_COOKIE", "") == "true"

	st, err := store.New(*dataDir)
	if err != nil {
		return err
	}
	if removed, missing, rerr := st.ReconcileBlobs(); rerr != nil {
		slog.Warn("reconciliação de anexos falhou", "err", rerr)
	} else {
		if removed > 0 || len(missing) > 0 {
			slog.Warn("anexos órfãos no boot", "blobsRemovidos", removed, "metadadosSemBlob", len(missing))
		}
		for _, id := range missing {
			slog.Warn("anexo sem blob", "id", id)
		}
	}

	handler := api.New(st, token, web.FS, api.Options{SecureCookie: secureCookie}).Handler()
	srv := &http.Server{
		Addr:              *addr,
		Handler:           handler,
		ReadHeaderTimeout: 5 * time.Second,
		ReadTimeout:       30 * time.Second,
		WriteTimeout:      60 * time.Second,
		IdleTimeout:       120 * time.Second,
	}

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

	errCh := make(chan error, 1)
	go func() {
		slog.Info("notas: servidor iniciando", "addr", *addr, "data", *dataDir)
		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			errCh <- err
		}
	}()

	select {
	case err := <-errCh:
		return err
	case <-ctx.Done():
		slog.Info("encerrando…")
		shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer cancel()
		return srv.Shutdown(shutdownCtx)
	}
}

func envOr(key, def string) string {
	if v := os.Getenv(key); v != "" {
		return v
	}
	return def
}