package renderer

import (
	"os"
	"path/filepath"
	"testing"

	"pdf-form-api/models"
)

const samplePDF = "../samples/OoPdfFormExample.pdf"

func TestGetPageInfo(t *testing.T) {
	pages, err := GetPageInfo(samplePDF)
	if err != nil {
		t.Fatalf("GetPageInfo returned error: %v", err)
	}

	if len(pages) == 0 {
		t.Fatal("expected at least one page")
	}

	t.Logf("Found %d pages", len(pages))
	for _, p := range pages {
		t.Logf("Page %d: %.0f x %.0f", p.Number, p.Width, p.Height)
	}
}

func TestGetPageInfoPageNumbers(t *testing.T) {
	pages, err := GetPageInfo(samplePDF)
	if err != nil {
		t.Fatalf("GetPageInfo: %v", err)
	}

	for i, p := range pages {
		expected := i + 1
		if p.Number != expected {
			t.Errorf("page %d: expected number %d, got %d", i, expected, p.Number)
		}
	}
}

func TestGetPageInfoDimensions(t *testing.T) {
	pages, err := GetPageInfo(samplePDF)
	if err != nil {
		t.Fatalf("GetPageInfo: %v", err)
	}

	for _, p := range pages {
		if p.Width <= 0 {
			t.Errorf("page %d: expected positive width, got %.0f", p.Number, p.Width)
		}
		if p.Height <= 0 {
			t.Errorf("page %d: expected positive height, got %.0f", p.Number, p.Height)
		}
	}
}

func TestGetPageInfoNonExistent(t *testing.T) {
	_, err := GetPageInfo("/nonexistent/path.pdf")
	if err == nil {
		t.Error("expected error for non-existent file")
	}
}

func TestGetPageInfoNotAPDF(t *testing.T) {
	tmp := t.TempDir()
	path := filepath.Join(tmp, "not_a_pdf.txt")
	if err := os.WriteFile(path, []byte("not a pdf"), 0o644); err != nil {
		t.Fatalf("WriteFile: %v", err)
	}

	_, err := GetPageInfo(path)
	if err == nil {
		t.Error("expected error for non-PDF file")
	}
}

func TestRenderPages(t *testing.T) {
	tmpDir := t.TempDir()
	imagePaths, err := RenderPages(samplePDF, tmpDir, 150)
	if err != nil {
		t.Fatalf("RenderPages: %v", err)
	}

	if len(imagePaths) == 0 {
		t.Fatal("expected at least one rendered image")
	}

	for _, imgPath := range imagePaths {
		if _, err := os.Stat(imgPath); err != nil {
			t.Errorf("rendered image not found: %s: %v", imgPath, err)
		}
	}

	t.Logf("Rendered %d pages to %s", len(imagePaths), tmpDir)
}

func TestRenderPagesNonExistent(t *testing.T) {
	tmpDir := t.TempDir()
	_, err := RenderPages("/nonexistent/path.pdf", tmpDir, 150)
	if err == nil {
		t.Error("expected error for non-existent PDF")
	}
}

func TestRenderPagesNotAPDF(t *testing.T) {
	tmpDir := t.TempDir()
	notPDF := filepath.Join(tmpDir, "not_a_pdf.txt")
	if err := os.WriteFile(notPDF, []byte("not a pdf"), 0o644); err != nil {
		t.Fatalf("WriteFile: %v", err)
	}

	_, err := RenderPages(notPDF, tmpDir, 150)
	if err == nil {
		t.Error("expected error for non-PDF file")
	}
}

func TestAnnotateImage(t *testing.T) {
	tmpDir := t.TempDir()

	imagePaths, err := RenderPages(samplePDF, tmpDir, 150)
	if err != nil {
		t.Fatalf("RenderPages: %v", err)
	}
	if len(imagePaths) == 0 {
		t.Fatal("no images rendered")
	}

	fields := []models.FormField{
		{ID: 1, Name: "TestField1", Type: models.FieldText, Rect: "100 700 300 720"},
		{ID: 2, Name: "TestField2", Type: models.FieldText, Rect: "100 600 300 620"},
	}
	labelMap := map[int64]string{1: "a3f1", 2: "b7e2"}

	outputPath := filepath.Join(tmpDir, "annotated.png")
	imgW, imgH := ComputeImageDimensions(612, 792, 150, 1024)
	err = AnnotateImage(imagePaths[0], outputPath, fields, labelMap, 612, 792, imgW, imgH)
	if err != nil {
		t.Fatalf("AnnotateImage: %v", err)
	}

	if _, err := os.Stat(outputPath); err != nil {
		t.Fatalf("annotated image not found: %v", err)
	}
}

func TestComputeImageDimensionsPortrait(t *testing.T) {
	w, h := ComputeImageDimensions(612, 792, 150, 1024)
	if w > 1024 || h > 1024 {
		t.Errorf("dimensions exceed max: %.0f x %.0f", w, h)
	}
	if h != 1024 {
		t.Errorf("portrait: expected height 1024, got %.2f", h)
	}
}

func TestComputeImageDimensionsLandscape(t *testing.T) {
	w, h := ComputeImageDimensions(792, 612, 150, 1024)
	if w > 1024 || h > 1024 {
		t.Errorf("dimensions exceed max: %.0f x %.0f", w, h)
	}
	if w != 1024 {
		t.Errorf("landscape: expected width 1024, got %.2f", w)
	}
}

func TestComputeImageDimensionsSmall(t *testing.T) {
	w, h := ComputeImageDimensions(100, 100, 72, 1024)
	if w != 100 || h != 100 {
		t.Errorf("small page should not be resized: %.0f x %.0f", w, h)
	}
}

func TestAnnotateImageEmptyFields(t *testing.T) {
	tmpDir := t.TempDir()

	imagePaths, err := RenderPages(samplePDF, tmpDir, 150)
	if err != nil {
		t.Fatalf("RenderPages: %v", err)
	}

	outputPath := filepath.Join(tmpDir, "annotated_empty.png")
	imgW, imgH := ComputeImageDimensions(612, 792, 150, 1024)
	err = AnnotateImage(imagePaths[0], outputPath, []models.FormField{}, nil, 612, 792, imgW, imgH)
	if err != nil {
		t.Fatalf("AnnotateImage with empty fields: %v", err)
	}
}