package main

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

	"database/sql"
	"common/db"
	"common/logger"
	"common/utils"
	"common/httpx"
	"user/internal/handler"
	"user/internal/repository"
	"user/internal/router"
	"user/internal/service"
)

var pg *sql.DB

func main() {
	port := utils.GetEnv("PORT", "8080")
	srv := &http.Server{
		Addr:    ":" + port,
		Handler: routes(),
	}

	var err error
	pg, err = db.InitPostgres()
	if err != nil {
		logger.L().Fatalf("postgres init: %v", err)
	}
	if utils.GetEnv("MIGRATE_ON_START", "0") == "1" {
		if err := applySchema("db/schema.sql"); err != nil {
			logger.L().Fatalf("apply schema: %v", err)
		}
	}

	logger.L().Printf("user service starting on :%s", port)

	go func() {
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			logger.L().Fatalf("listen: %v", err)
		}
	}()

	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	logger.L().Printf("user service shutting down...")

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := srv.Shutdown(ctx); err != nil {
		logger.L().Printf("server shutdown: %v", err)
	}
	_ = db.ClosePostgres()
	logger.L().Printf("user service exited")
}

func routes() http.Handler {
	repo := repository.New(pg)
	svc := service.New(repo)
	h := handler.New(svc)
	cors := httpx.CORS()
	return cors(router.New(h))
}

func applySchema(path string) error {
	b, err := os.ReadFile(path)
	if err != nil {
		return err
	}
	_, err = pg.Exec(string(b))
	return err
}