package server

import (
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"testing"

	"vidarchive/internal/config"
	"vidarchive/internal/database"
	"vidarchive/internal/handler"
	"vidarchive/internal/repository"
	"vidarchive/internal/service"
	"vidarchive/internal/worker"
)

func setupTestServer(t *testing.T) (*Server, *config.Config, func()) {
	t.Helper()
	dataDir := t.TempDir()
	t.Setenv("VIDARCHIVE_DATA_DIR", dataDir)

	cfg := config.New()
	if err := os.MkdirAll(cfg.LibraryDir, 0755); err != nil {
		t.Fatalf("create library dir: %v", err)
	}
	if err := os.MkdirAll(cfg.TempDir, 0755); err != nil {
		t.Fatalf("create temp dir: %v", err)
	}

	db, err := database.New(cfg)
	if err != nil {
		t.Fatalf("init db: %v", err)
	}

	presetRepo := repository.NewPresetRepository(db)
	downloadRepo := repository.NewDownloadRepository(db)
	settingsRepo := repository.NewSettingsRepository(db)

	presetSvc := service.NewPresetService(presetRepo)
	librarySvc := service.NewLibraryService(cfg.LibraryDir, cfg.TempDir)
	settingsSvc := service.NewSettingsService(settingsRepo)
	downloadSvc := service.NewDownloadService(downloadRepo, librarySvc, presetSvc, settingsSvc, cfg)
	workerPool := worker.New(downloadSvc, cfg.Workers)

	h, err := handler.New(cfg, presetSvc, downloadSvc, librarySvc, settingsSvc, workerPool)
	if err != nil {
		t.Fatalf("init handler: %v", err)
	}

	srv := New(cfg, h)
	cleanup := func() {
		workerPool.Stop()
		db.Close()
	}
	return srv, cfg, cleanup
}

func createItem(t *testing.T, libraryDir, relPath, name string, files map[string]string) {
	t.Helper()
	itemDir := filepath.Join(libraryDir, relPath)
	if err := os.MkdirAll(itemDir, 0755); err != nil {
		t.Fatalf("create item dir: %v", err)
	}
	marker := filepath.Join(itemDir, ".vidarchive-item.toml")
	if err := os.WriteFile(marker, []byte("name = \""+name+"\"\nduration = -1\n"), 0644); err != nil {
		t.Fatalf("write marker: %v", err)
	}
	for filename, content := range files {
		path := filepath.Join(itemDir, filename)
		if err := os.WriteFile(path, []byte(content), 0644); err != nil {
			t.Fatalf("write file %s: %v", filename, err)
		}
	}
}

func TestNestedLibraryItem(t *testing.T) {
	srv, cfg, cleanup := setupTestServer(t)
	defer cleanup()

	createItem(t, cfg.LibraryDir, "test/My Item [id]", "My Item", map[string]string{
		"My Item [id].mp4": "dummy video",
	})

	router := srv.Router()

	tests := []string{
		"/library/item/test/My%20Item%20%5Bid%5D",
		"/library/item/test/My+Item+%5Bid%5D",
	}
	for _, path := range tests {
		req := httptest.NewRequest("GET", path, nil)
		w := httptest.NewRecorder()
		router.ServeHTTP(w, req)
		if w.Code != http.StatusOK {
			body, _ := io.ReadAll(w.Body)
			t.Errorf("%s: expected 200, got %d: %s", path, w.Code, string(body))
		}
	}
}

func TestMediaFileQueryDecoding(t *testing.T) {
	srv, cfg, cleanup := setupTestServer(t)
	defer cleanup()

	createItem(t, cfg.LibraryDir, "My Item [id]", "My Item", map[string]string{
		"My Item [id].mp4": "dummy video",
		"My+Other.mp4":     "dummy video plus",
	})

	router := srv.Router()

	tests := []struct {
		path     string
		expected int
	}{
		{"/media/item/My%20Item%20%5Bid%5D?file=My+Item+%5Bid%5D.mp4", http.StatusOK},
		{"/media/item/My%20Item%20%5Bid%5D?file=My%20Item%20%5Bid%5D.mp4", http.StatusOK},
		{"/media/item/My%20Item%20%5Bid%5D?file=My%2BOther.mp4", http.StatusOK},
		{"/media/item/My%20Item%20%5Bid%5D?file=missing.mp4", http.StatusNotFound},
	}
	for _, tc := range tests {
		req := httptest.NewRequest("GET", tc.path, nil)
		w := httptest.NewRecorder()
		router.ServeHTTP(w, req)
		if w.Code != tc.expected {
			body, _ := io.ReadAll(w.Body)
			t.Errorf("%s: expected %d, got %d: %s", tc.path, tc.expected, w.Code, string(body))
		}
	}
}

func TestPathTraversalBlocked(t *testing.T) {
	srv, cfg, cleanup := setupTestServer(t)
	defer cleanup()

	outside := filepath.Join(cfg.DataDir, "secret")
	if err := os.MkdirAll(outside, 0755); err != nil {
		t.Fatalf("create outside dir: %v", err)
	}
	marker := filepath.Join(outside, ".vidarchive-item.toml")
	if err := os.WriteFile(marker, []byte("name = \"secret\"\nduration = -1\n"), 0644); err != nil {
		t.Fatalf("write marker: %v", err)
	}

	router := srv.Router()

	req := httptest.NewRequest("GET", "/library/item/../secret", nil)
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)
	if w.Code != http.StatusNotFound {
		t.Errorf("expected 404 for path traversal, got %d", w.Code)
	}
}

func TestExistingImageThumbnail(t *testing.T) {
	srv, cfg, cleanup := setupTestServer(t)
	defer cleanup()

	createItem(t, cfg.LibraryDir, "thumb-item", "Thumb Item", map[string]string{
		"cover.jpg": "fake image",
		"video.mp4": "dummy video",
	})

	router := srv.Router()
	req := httptest.NewRequest("GET", "/media/item/thumb-item/thumbnail", nil)
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)
	if w.Code != http.StatusOK {
		body, _ := io.ReadAll(w.Body)
		t.Fatalf("expected 200, got %d: %s", w.Code, string(body))
	}
	if body, _ := io.ReadAll(w.Body); string(body) != "fake image" {
		t.Errorf("expected cover.jpg contents, got %q", string(body))
	}
}

func TestAudioThumbnailPlaceholder(t *testing.T) {
	srv, cfg, cleanup := setupTestServer(t)
	defer cleanup()

	createItem(t, cfg.LibraryDir, "audio-item", "Audio Item", map[string]string{
		"song.mp3": "dummy audio",
	})

	router := srv.Router()
	req := httptest.NewRequest("GET", "/media/item/audio-item/thumbnail", nil)
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)
	if w.Code != http.StatusOK {
		body, _ := io.ReadAll(w.Body)
		t.Fatalf("expected 200, got %d: %s", w.Code, string(body))
	}
	body, _ := io.ReadAll(w.Body)
	if len(body) == 0 {
		t.Errorf("placeholder thumbnail body was empty")
	}
}

func TestLibraryPageIsFast(t *testing.T) {
	srv, cfg, cleanup := setupTestServer(t)
	defer cleanup()

	for i := 0; i < 50; i++ {
		createItem(t, cfg.LibraryDir, "item-"+string(rune('a'+i)), "Item", map[string]string{
			"video.mp4": "dummy",
		})
	}

	router := srv.Router()
	req := httptest.NewRequest("GET", "/library", nil)
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)
	if w.Code != http.StatusOK {
		body, _ := io.ReadAll(w.Body)
		t.Fatalf("expected 200, got %d: %s", w.Code, string(body))
	}
}