package main

import (
	"context"
	"errors"
	"kooltap-updateserver/internal/db"
	"kooltap-updateserver/internal/routes"
	"log"
	"net/http"
	"os"
	"os/signal"
	"strconv"
	"syscall"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/joho/godotenv"
)

func main() {

	_ = godotenv.Load()

	dsn := os.Getenv("DATABASE_URL")
	if dsn == "" {
		log.Fatal("DATABASE_URL is required, e.g. postgres://user:pass@host:5432/kooltap?sslmode=disable")
	}

	database, err := db.Connect(dsn)
	if err != nil {
		log.Fatal(err)
	}

	// One-time migration of the old file based database, if it is still mounted
	if err := db.ImportSQLite(database, env("SQLITE_IMPORT_PATH", "data/updater.db")); err != nil {
		log.Fatal(err)
	}

	h := &routes.Handler{
		DB:        database,
		UploadDir: env("UPLOAD_DIR", "uploads"),
		TmpDir:    env("TMP_DIR", "tmp"),
		MaxUpload: int64(envInt("MAX_UPLOAD_MB", 300)) << 20,
	}

	for _, dir := range []string{h.UploadDir, h.TmpDir} {
		if err := os.MkdirAll(dir, 0755); err != nil {
			log.Fatal(err)
		}
	}

	r := gin.Default()

	// No proxy headers are used for anything, so do not trust any
	_ = r.SetTrustedProxies(nil)

	r.Use(func(c *gin.Context) {
		c.Header("Server", "KoolTap Updater")
		c.Next()
	})

	r.Static("/downloads", h.UploadDir)

	r.GET("/", func(c *gin.Context) {
		sqlDB, err := database.DB()
		if err == nil {
			err = sqlDB.PingContext(c.Request.Context())
		}
		if err != nil {
			c.JSON(http.StatusServiceUnavailable, gin.H{"status": "database unavailable"})
			return
		}
		c.JSON(http.StatusOK, gin.H{"status": "ok"})
	})

	h.Register(r)

	srv := &http.Server{
		Addr:              ":" + env("PORT", "3000"),
		Handler:           r,
		ReadHeaderTimeout: 10 * time.Second,
	}

	go func() {
		log.Printf("listening on %s", srv.Addr)
		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Fatal(err)
		}
	}()

	// Let in-flight uploads finish when the container is stopped
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()
	<-ctx.Done()

	log.Println("shutting down")
	shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	if err := srv.Shutdown(shutdownCtx); err != nil {
		log.Printf("shutdown: %v", err)
	}
	if sqlDB, err := database.DB(); err == nil {
		sqlDB.Close()
	}
}

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

func envInt(key string, fallback int) int {
	if v, err := strconv.Atoi(os.Getenv(key)); err == nil && v > 0 {
		return v
	}
	return fallback
}