package main

import (
	"context"
	"database/sql"
	"errors"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	diun "awesomeProject/pkg/diunwebhook"
	_ "github.com/jackc/pgx/v5/stdlib"
	_ "modernc.org/sqlite"
)

func main() {
	databaseURL := os.Getenv("DATABASE_URL")
	var store diun.Store
	if databaseURL != "" {
		db, err := sql.Open("pgx", databaseURL)
		if err != nil {
			log.Fatalf("sql.Open postgres: %v", err)
		}
		if err := diun.RunPostgresMigrations(db); err != nil {
			log.Fatalf("RunPostgresMigrations: %v", err)
		}
		store = diun.NewPostgresStore(db)
		log.Println("Using PostgreSQL database")
	} else {
		dbPath := os.Getenv("DB_PATH")
		if dbPath == "" {
			dbPath = "./diun.db"
		}
		db, err := sql.Open("sqlite", dbPath)
		if err != nil {
			log.Fatalf("sql.Open sqlite: %v", err)
		}
		if err := diun.RunSQLiteMigrations(db); err != nil {
			log.Fatalf("RunSQLiteMigrations: %v", err)
		}
		store = diun.NewSQLiteStore(db)
		log.Printf("Using SQLite database at %s", dbPath)
	}

	secret := os.Getenv("WEBHOOK_SECRET")
	if secret == "" {
		log.Println("WARNING: WEBHOOK_SECRET not set — webhook endpoint is unprotected")
	} else {
		log.Println("Webhook endpoint protected with token authentication")
	}

	srv := diun.NewServer(store, secret)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	mux := http.NewServeMux()
	mux.HandleFunc("/webhook", srv.WebhookHandler)
	mux.HandleFunc("/api/updates/", srv.DismissHandler)
	mux.HandleFunc("/api/updates", srv.UpdatesHandler)
	mux.HandleFunc("/api/tags", srv.TagsHandler)
	mux.HandleFunc("/api/tags/", srv.TagByIDHandler)
	mux.HandleFunc("/api/tag-assignments", srv.TagAssignmentHandler)
	mux.Handle("/", http.FileServer(http.Dir("./frontend/dist")))

	httpSrv := &http.Server{
		Addr:         ":" + port,
		Handler:      mux,
		ReadTimeout:  10 * time.Second,
		WriteTimeout: 10 * time.Second,
		IdleTimeout:  60 * time.Second,
	}

	stop := make(chan os.Signal, 1)
	signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)

	go func() {
		log.Printf("Listening on :%s", port)
		if err := httpSrv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Fatalf("ListenAndServe: %v", err)
		}
	}()

	<-stop

	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	if err := httpSrv.Shutdown(ctx); err != nil {
		log.Printf("Shutdown error: %v", err)
	} else {
		log.Println("Server stopped cleanly")
	}
}