package main

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

	commondb "gitea.estateliga.work/admin/portal-common/db"
	commonmw "gitea.estateliga.work/admin/portal-common/middleware"
	"github.com/go-chi/chi/v5"
	chimw "github.com/go-chi/chi/v5/middleware"

	"files-service/internal/config"
	"files-service/internal/handler"
	"files-service/internal/migrate"
	"files-service/internal/repository"
	"files-service/internal/storage"
)

func main() {
	slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo})))

	cfg := config.Load()
	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	pool, err := commondb.ConnectWithRetry(ctx, cfg.DatabaseURL, 2*time.Minute)
	if err != nil {
		slog.Error("connect database", "error", err)
		os.Exit(1)
	}
	defer pool.Close()

	if err := migrate.Run(context.Background(), pool, cfg.MigrationsDir); err != nil {
		slog.Error("run migrations", "error", err)
		os.Exit(1)
	}

	store, err := storage.New(storage.Config{
		Endpoint:  cfg.MinIOEndpoint,
		AccessKey: cfg.MinIOAccessKey,
		SecretKey: cfg.MinIOSecretKey,
		Bucket:    cfg.MinIOBucket,
		UseSSL:    cfg.MinIOUseSSL,
	})
	if err != nil {
		slog.Error("init storage", "error", err)
		os.Exit(1)
	}
	if err := store.EnsureBucket(ctx); err != nil {
		slog.Warn("ensure bucket failed", "error", err)
	}

	healthH := handler.NewHealthHandler(pool)
	nodeH := handler.NewNodeHandler(cfg, repository.NewNodeRepository(pool), store)

	r := chi.NewRouter()
	r.Use(chimw.RequestID)
	r.Use(chimw.RealIP)
	r.Use(chimw.Recoverer)

	r.Get("/healthz", healthH.Healthz)
	r.Get("/readyz", healthH.Readyz)

	r.Route("/api", func(r chi.Router) {
		r.Use(commonmw.InternalAuth(cfg.InternalAPIKey))
		r.Get("/nodes", nodeH.List)
		r.Post("/folders", nodeH.CreateFolder)
		r.Post("/files", nodeH.UploadFile)
		r.Route("/nodes/{id}", func(r chi.Router) {
			r.Get("/", nodeH.Get)
			r.Patch("/", nodeH.Update)
			r.Delete("/", nodeH.Delete)
			r.Get("/download", nodeH.Download)
			r.Get("/access", nodeH.ListAccess)
			r.Put("/access", nodeH.ReplaceAccess)
			r.Post("/public-links", nodeH.CreatePublicLink)
		})
	})

	r.Get("/public/{token}", nodeH.PublicMeta)
	r.Get("/public/{token}/download", nodeH.PublicDownload)

	srv := &http.Server{
		Addr:         ":" + cfg.ServerPort,
		Handler:      r,
		ReadTimeout:  15 * time.Second,
		WriteTimeout: 10 * time.Minute,
		IdleTimeout:  60 * time.Second,
	}

	go func() {
		slog.Info("files server starting", "port", cfg.ServerPort, "pod", cfg.PodName)
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			slog.Error("server error", "error", err)
			os.Exit(1)
		}
	}()

	<-ctx.Done()
	shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	if err := srv.Shutdown(shutdownCtx); err != nil {
		slog.Error("server shutdown error", "error", err)
	}
}