package main

import (
	"bufio"
	"log"
	"net/http"
	"os"
	"strings"

	"go-backend/internal/database"
	"go-backend/internal/database/sqlc"
	"go-backend/internal/handlers"
	"go-backend/internal/services"
)

// loadEnvFile sets environment variables from a KEY=VALUE .env file,
// without overriding vars already set in the environment.
func loadEnvFile(path string) error {
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close()

	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line == "" || strings.HasPrefix(line, "#") {
			continue
		}
		key, value, ok := strings.Cut(line, "=")
		if !ok {
			continue
		}
		key = strings.TrimSpace(key)
		if _, exists := os.LookupEnv(key); exists {
			continue
		}
		os.Setenv(key, strings.TrimSpace(value))
	}
	return scanner.Err()
}

func main() {
	if err := loadEnvFile(".env"); err != nil {
		log.Println("No .env file found")
	}

	db, err := database.Connect()
	if err != nil {
		log.Fatal("Failed to connect to database:", err)
	}
	defer db.Close()

	queries := sqlc.New(db)

	userService := services.NewUserService(db, queries)
	authService := services.NewAuthService(db, queries)

	templateCache, err := handlers.NewTemplateCache()
	if err != nil {
		log.Fatal("Failed to parse templates:", err)
	}

	handler := handlers.NewHandler(userService, authService, templateCache)

	mux := http.NewServeMux()

	mux.Handle("GET /static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./ui/static"))))

	mux.HandleFunc("GET /{$}", handler.HomePageHandler)
	mux.HandleFunc("GET /login", handler.LoginPageHandler)
	mux.HandleFunc("GET /signup", handler.SignUpPageHandler)
	mux.HandleFunc("GET /settings", handler.SettingsPageHandler)

	mux.HandleFunc("POST /api/login", handler.LoginHandler)
	mux.HandleFunc("POST /api/logout", handler.LogoutHandler)
	mux.HandleFunc("POST /api/signup", handler.SignUpHandler)
	mux.HandleFunc("PATCH /api/user", handler.PatchUserHandler)

	muxMiddleware := handlers.LoggingMiddleware(handlers.CORSMiddleware(mux))

	port := getEnv("PORT", "8080")
	log.Printf("Server starting on port %s", port)

	if err := http.ListenAndServe(":"+port, muxMiddleware); err != nil {
		log.Fatal("Server failed to start:", err)
	}
}

func getEnv(key, defaultValue string) string {
	if value := os.Getenv(key); value != "" {
		return value
	}
	return defaultValue
}