package main

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

	"ddc/internal/auth"
	"ddc/internal/config"
	"ddc/internal/history"
	"ddc/internal/jobs"
	"ddc/internal/logging"
	"ddc/internal/preferences"
	"ddc/internal/server"
)

const (
	settingsFileName = ".settings.json"
	historyFileName  = ".history.json"
	shutdownTimeout  = 10 * time.Second
)

func main() {
	settings, err := config.Load()
	if err != nil {
		logging.Fatal("configuration error", err)
	}
	if err := logging.Setup(settings.LogLevel, settings.LogFormat); err != nil {
		logging.Fatal("logging configuration error", err)
	}

	if err := prepareDownloadDir(&settings); err != nil {
		logging.Fatal("download directory error", err, "path", settings.DownloadDir)
	}

	store, err := preferences.Open(filepath.Join(settings.DownloadDir, settingsFileName), settings.Defaults)
	if err != nil {
		logging.Fatal("could not load settings", err)
	}
	historyStore, err := history.Open(filepath.Join(settings.DownloadDir, historyFileName))
	if err != nil {
		logging.Fatal("could not load history", err)
	}

	manager := jobs.NewManager(settings, store, historyStore)
	if err := manager.RestoreExisting(); err != nil {
		slog.Error("could not restore existing downloads", "error", err)
	}

	sessions := auth.NewSessionStore(settings.SessionTTL)
	httpServer := &http.Server{
		Addr:              settings.ListenAddr,
		Handler:           server.New(settings, sessions, manager),
		ErrorLog:          slog.NewLogLogger(slog.Default().Handler(), slog.LevelWarn),
		ReadHeaderTimeout: 10 * time.Second,
		ReadTimeout:       30 * time.Second,
		WriteTimeout:      60 * time.Second,
		IdleTimeout:       120 * time.Second,
	}

	shutdownSignal, stopListening := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stopListening()

	go func() {
		slog.Info("server started",
			"listen", settings.ListenAddr,
			"download_dir", settings.DownloadDir,
			"library_roots", settings.LibraryRoots,
			"log_level", settings.LogLevel,
		)
		if err := httpServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			logging.Fatal("server stopped unexpectedly", err)
		}
	}()

	<-shutdownSignal.Done()
	slog.Info("shutting down, saving download progress")
	shutdownContext, cancel := context.WithTimeout(context.Background(), shutdownTimeout)
	defer cancel()
	manager.Shutdown(shutdownContext)
	if err := httpServer.Shutdown(shutdownContext); err != nil {
		slog.Error("shutdown did not finish cleanly", "error", err)
	}
	slog.Info("stopped")
}

func prepareDownloadDir(settings *config.Settings) error {
	if err := os.MkdirAll(settings.DownloadDir, 0o755); err != nil {
		return err
	}
	resolved, err := filepath.EvalSymlinks(settings.DownloadDir)
	if err != nil {
		return err
	}
	settings.DownloadDir = resolved
	if err := ensureWritable(resolved); err != nil {
		return fmt.Errorf("not writable by uid %d gid %d: %w", os.Getuid(), os.Getgid(), err)
	}
	return nil
}

func ensureWritable(directory string) error {
	probe, err := os.CreateTemp(directory, ".write-test-*")
	if err != nil {
		return err
	}
	probe.Close()
	return os.Remove(probe.Name())
}