package main

import (
	"database/sql"
	"fmt"
	"io/fs"
	"net/http"
	"os"
	"strconv"

	userctx "git.kealoha.me/lks/lenslocked/context"
	ctrlrs "git.kealoha.me/lks/lenslocked/controllers"
	"git.kealoha.me/lks/lenslocked/migrations"
	"git.kealoha.me/lks/lenslocked/models"
	"github.com/go-chi/chi/v5"
	"github.com/gorilla/csrf"
	"github.com/joho/godotenv"
	"github.com/pressly/goose/v3"

	"github.com/go-chi/chi/v5/middleware"
	_ "github.com/jackc/pgx/v4/stdlib"
)

const DEBUG bool = true

func notFoundHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/html; charset=utf8")
	w.WriteHeader(http.StatusNotFound)
	fmt.Fprint(w, "404 page not found")
}

func ConnectDB() *sql.DB {
	db, err := sql.Open("pgx", os.Getenv("LENSLOCKED_DB_STRING"))
	if err != nil {
		panic(fmt.Sprint("Error connecting to database: %w", err))
	}
	err = db.Ping()
	if err != nil {
		panic(fmt.Sprint("Error connecting to database: %w", err))
	}
	return db
}
func MigrateDB(db *sql.DB, subfs fs.FS) error {
	goose.SetBaseFS(subfs)
	defer func() { goose.SetBaseFS(nil) }()
	err := goose.SetDialect("postgres")
	if err != nil {
		return fmt.Errorf("Migrate: %w", err)
	}
	err = goose.Up(db, ".")
	if err != nil {
		return fmt.Errorf("Migrate: %w", err)
	}
	return nil
}

func main() {
	err := godotenv.Load()
	if err != nil {
		fmt.Println("Warning: Could not load .env file")
	}

	var (
		email_host     = os.Getenv("LENSLOCKED_EMAIL_HOST")
		email_port_str = os.Getenv("LENSLOCKED_EMAIL_PORT")
		email_username = os.Getenv("LENSLOCKED_EMAIL_USERNAME")
		email_pass     = os.Getenv("LENSLOCKED_EMAIL_PASSWORD")
		email_sender   = os.Getenv("LENSLOCKED_EMAIL_FROM")
		csrfKey        = []byte(os.Getenv("LENSLOCKED_CSRF_KEY"))
	)
	if len(csrfKey) < 32 {
		panic("Error: no or bad csrf protection key\nPlease set the LENSLOCKED_CSRF_KEY env var to a key at least 32 characters long.")
	}
	email_port, err := strconv.Atoi(email_port_str)
	if err != nil {
		fmt.Println("Warning: Invalid STMP port set in LENSLOCKED_EMAIL_PORT. Using port 587")
		email_port = 587
	}

	db := ConnectDB()
	defer db.Close()
	err = MigrateDB(db, migrations.FS)
	if err != nil {
		panic(err)
	}

	userService := models.UserService{DB: db}
	sessionService := models.SessionService{DB: db}
	_ = models.NewEmailService(email_host, email_port, email_username, email_pass, email_sender)
	var usersCtrlr ctrlrs.Users = ctrlrs.Default(&userService, &sessionService)

	umw := userctx.UserMiddleware{SS: &sessionService}

	r := chi.NewRouter()

	r.Use(middleware.Logger)
	r.Use(csrf.Protect(csrfKey, csrf.Secure(!DEBUG)))
	r.Use(umw.SetUser)

	r.Get("/", ctrlrs.StaticController("home.gohtml", "tailwind.gohtml"))
	r.Get("/contact", ctrlrs.StaticController("contact.gohtml", "tailwind.gohtml"))
	r.Get("/faq", ctrlrs.FAQ("faq.gohtml", "tailwind.gohtml"))

	r.Get("/signup", usersCtrlr.GetSignup)
	r.Post("/signup", usersCtrlr.PostSignup)
	r.Get("/signin", usersCtrlr.GetSignin)
	r.Post("/signin", usersCtrlr.PostSignin)
	r.Post("/signout", usersCtrlr.GetSignout)

	//r.Get("/user", usersCtrlr.CurrentUser)
	r.Get("/user", umw.RequireUserfn(usersCtrlr.CurrentUser))
	r.NotFound(notFoundHandler)

	fmt.Println("Starting the server on :3000...")
	http.ListenAndServe(":3000", r)
}