package application

import (
	"net/http"
	"testing"
	"testing/fstest"
)

func TestWithValue_SetsTemplateValue(t *testing.T) {
	app := New(WithValue("siteName", "TestSite"))

	funcs := app.templateFuncs()
	fn, ok := funcs["siteName"]
	if !ok {
		t.Fatal("expected 'siteName' func to be registered")
	}

	// The func should return the value
	result := fn.(func() any)()
	if result != "TestSite" {
		t.Errorf("expected 'TestSite', got %v", result)
	}
}

func TestWithFunc_RegistersTemplateFunction(t *testing.T) {
	add := func(a, b int) int { return a + b }
	app := New(WithFunc("add", add))

	funcs := app.templateFuncs()
	_, ok := funcs["add"]
	if !ok {
		t.Fatal("expected 'add' func to be registered")
	}
}

func TestWithMiddleware_AddsMiddleware(t *testing.T) {
	called := false
	mw := func(next http.Handler) http.Handler {
		called = true
		return next
	}

	app := New(WithMiddleware(mw))

	if len(app.middlewares) != 1 {
		t.Fatalf("expected 1 middleware, got %d", len(app.middlewares))
	}

	// Execute the middleware to verify it was stored
	app.middlewares[0](http.DefaultServeMux)
	if !called {
		t.Error("expected middleware to be called")
	}
}

func TestWithMiddleware_MultipleMiddlewares(t *testing.T) {
	mw1 := func(next http.Handler) http.Handler { return next }
	mw2 := func(next http.Handler) http.Handler { return next }
	mw3 := func(next http.Handler) http.Handler { return next }

	app := New(
		WithMiddleware(mw1),
		WithMiddleware(mw2),
		WithMiddleware(mw3),
	)

	if len(app.middlewares) != 3 {
		t.Errorf("expected 3 middlewares, got %d", len(app.middlewares))
	}
}

func TestWithHealthPath_SetsHealthPath(t *testing.T) {
	app := New(WithHealthPath("/healthz"))

	if app.healthPath != "/healthz" {
		t.Errorf("expected '/healthz', got %q", app.healthPath)
	}
}

func TestWithHealthPath_DefaultEmpty(t *testing.T) {
	app := New()

	if app.healthPath != "" {
		t.Errorf("expected empty healthPath by default, got %q", app.healthPath)
	}
}

type testController struct {
	BaseController
	setupCalled bool
}

func (c *testController) Handle(r *http.Request) Controller {
	return c
}

func (c *testController) Setup(app *App) {
	c.BaseController.Setup(app)
	c.setupCalled = true
}

func TestWithController_RegistersController(t *testing.T) {
	ctrl := &testController{}
	app := New(WithController("test", ctrl))

	if _, ok := app.controllers["test"]; !ok {
		t.Fatal("expected controller to be registered")
	}

	if !ctrl.setupCalled {
		t.Error("expected Setup to be called on controller")
	}
}

func TestWithController_MultipleControllers(t *testing.T) {
	ctrl1 := &testController{}
	ctrl2 := &testController{}

	app := New(
		WithController("home", ctrl1),
		WithController("admin", ctrl2),
	)

	if len(app.controllers) != 2 {
		t.Errorf("expected 2 controllers, got %d", len(app.controllers))
	}
	if _, ok := app.controllers["home"]; !ok {
		t.Error("expected 'home' controller")
	}
	if _, ok := app.controllers["admin"]; !ok {
		t.Error("expected 'admin' controller")
	}
}

func TestNew_AppliesOptions(t *testing.T) {
	ctrl := &testController{}

	app := New(
		WithValue("brand", "Congo"),
		WithHealthPath("/up"),
		WithController("main", ctrl),
		WithMiddleware(func(next http.Handler) http.Handler { return next }),
	)

	if app == nil {
		t.Fatal("expected non-nil App")
	}
	if app.healthPath != "/up" {
		t.Errorf("expected healthPath '/up', got %q", app.healthPath)
	}
	if len(app.controllers) != 1 {
		t.Errorf("expected 1 controller, got %d", len(app.controllers))
	}
	if len(app.middlewares) != 1 {
		t.Errorf("expected 1 middleware, got %d", len(app.middlewares))
	}

	funcs := app.templateFuncs()
	if _, ok := funcs["brand"]; !ok {
		t.Error("expected 'brand' func to be registered")
	}
}

func TestNew_EmptyOptions(t *testing.T) {
	app := New()

	if app == nil {
		t.Fatal("expected non-nil App")
	}
	if app.funcs == nil {
		t.Error("expected non-nil funcs map")
	}
	if app.controllers == nil {
		t.Error("expected non-nil controllers map")
	}
	if len(app.funcs) != 0 {
		t.Errorf("expected empty funcs, got %d", len(app.funcs))
	}
	if len(app.controllers) != 0 {
		t.Errorf("expected empty controllers, got %d", len(app.controllers))
	}
}

func TestWithViews_SetsViewsFS(t *testing.T) {
	views := fstest.MapFS{
		"views/layouts/base.html": {Data: []byte(`{{define "base.html"}}base{{end}}`)},
	}

	app := New(WithViews(views))

	if app.viewsFS == nil {
		t.Error("expected viewsFS to be set")
	}
	if app.base == nil {
		t.Error("expected base templates to be parsed")
	}
}

func TestWithEmailer_SetsEmailer(t *testing.T) {
	// Emailer is an interface; use nil to verify the option function runs
	app := New(WithEmailer(nil))

	if app.Emailer != nil {
		t.Error("expected nil emailer")
	}
}