package main

import (
	"database/sql"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"sort"
	"strings"
	"text/template"
	"time"
	"unicode"

	_ "github.com/mattn/go-sqlite3"
)

const (
	dbPath    = "data/forms.db"
	pdfDir    = "data/pdfs"
	port      = ":8080"
	maxUpload = 10 << 20 // 10MB
)

// Form represents a stored PDF form
type Form struct {
	ID          int64     `json:"id"`
	Name        string    `json:"name"`
	PDFPath     string    `json:"pdf_path"`
	HTMLContent string    `json:"html_content"`
	FieldMeta   string    `json:"field_meta"` // JSON mapping of html_name -> pdf_name + type
	CreatedAt   time.Time `json:"created_at"`
}

// PDFField represents a form field in a PDF
type PDFField struct {
	Name         string
	Type         string
	DefaultValue string
	Rect         string
	Required     bool
	MaxLength    int
	Options      []string // from FieldStateOption
	Alt          string   // from FieldNameAlt
}

// FieldMapping stores the relationship between HTML names and PDF names
type FieldMapping struct {
	HTMLName       string `json:"html_name"`
	PDFName        string `json:"pdf_name"`
	Type           string `json:"type"`
	PseudoCheckbox bool   `json:"pseudo_checkbox"`
	// CheckboxField is the html_name of the paired "Other" checkbox, set on the "Other specify" text input
	CheckboxField string `json:"checkbox_field"`
}

var db *sql.DB
var templates *template.Template

func isPDFTKInstalled() bool {
	_, err := exec.LookPath("pdftk")
	return err == nil
}

func isPDFToPPMInstalled() bool {
	_, err := exec.LookPath("pdftoppm")
	return err == nil
}

func main() {
	os.MkdirAll("data", 0755)
	os.MkdirAll(pdfDir, 0755)
	os.MkdirAll("static", 0755)

	var err error
	db, err = sql.Open("sqlite3", dbPath+"?_busy_timeout=5000")
	if err != nil {
		log.Fatalf("Failed to open database: %v", err)
	}
	defer db.Close()
	db.SetMaxOpenConns(1)

	if err = initDB(); err != nil {
		log.Fatalf("Failed to initialize database: %v", err)
	}

	templates, err = template.ParseGlob("templates/*.html")
	if err != nil {
		log.Fatalf("Failed to parse templates: %v", err)
	}

	http.HandleFunc("/admin/", handleAdmin)
	http.HandleFunc("/admin/upload", handleAdminUpload)
	http.HandleFunc("/admin/delete", handleDelete)
	http.HandleFunc("/admin/convert", handleConvert)
	http.HandleFunc("/form/", handleForm)
	http.Handle("/", http.FileServer(http.Dir("static")))

	log.Printf("Server starting on %s", port)
	log.Printf("Admin panel: http://localhost%s/admin", port)
	log.Fatal(http.ListenAndServe(port, nil))
}

func initDB() error {
	schema := `
	CREATE TABLE IF NOT EXISTS forms (
		id INTEGER PRIMARY KEY AUTOINCREMENT,
		name TEXT NOT NULL,
		pdf_path TEXT NOT NULL,
		html_content TEXT NOT NULL DEFAULT '',
		field_meta TEXT NOT NULL DEFAULT '',
		created_at DATETIME DEFAULT CURRENT_TIMESTAMP
	);
	`
	_, err := db.Exec(schema)
	return err
}

// ---- ADMIN HANDLERS ----

type adminData struct {
	Forms       []Form
	Status      string
	OpenAIKey   bool
	OpenAIModel string
	PDFTK       bool
	PDFToPPM    bool
}

func handleAdmin(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/admin" && r.URL.Path != "/admin/" {
		http.NotFound(w, r)
		return
	}
	if r.Method != http.MethodGet {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	forms, err := getForms()
	if err != nil {
		http.Error(w, "Database error", http.StatusInternalServerError)
		return
	}

	data := adminData{
		Forms:       forms,
		Status:      r.URL.Query().Get("status"),
		OpenAIKey:   os.Getenv("OPENAI_API_KEY") != "",
		OpenAIModel: os.Getenv("OPENAI_MODEL"),
		PDFTK:       isPDFTKInstalled(),
		PDFToPPM:    isPDFToPPMInstalled(),
	}
	if data.OpenAIModel == "" {
		data.OpenAIModel = "gpt-4o"
	}
	templates.ExecuteTemplate(w, "admin.html", data)
}

func handleAdminUpload(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	r.Body = http.MaxBytesReader(w, r.Body, maxUpload)
	if err := r.ParseMultipartForm(maxUpload); err != nil {
		http.Error(w, "File too large", http.StatusBadRequest)
		return
	}

	file, header, err := r.FormFile("pdf")
	if err != nil {
		http.Error(w, "No file uploaded", http.StatusBadRequest)
		return
	}
	defer file.Close()

	name := r.FormValue("name")
	if name == "" {
		name = header.Filename
	}

	timestamp := time.Now().Format("20060102_150405")
	ext := filepath.Ext(header.Filename)
	sanitized := strings.ReplaceAll(name, "/", "_")
	sanitized = strings.ReplaceAll(sanitized, "\\", "_")
	filename := fmt.Sprintf("%s_%s%s", timestamp, sanitized, ext)
	pdfPath := filepath.Join(pdfDir, filename)

	dst, err := os.Create(pdfPath)
	if err != nil {
		http.Error(w, "Failed to save file", http.StatusInternalServerError)
		return
	}
	defer dst.Close()

	if _, err = io.Copy(dst, file); err != nil {
		http.Error(w, "Failed to save file", http.StatusInternalServerError)
		return
	}

	_, err = db.Exec("INSERT INTO forms (name, pdf_path, html_content, field_meta) VALUES (?, ?, '', '')",
		name, pdfPath)
	if err != nil {
		http.Error(w, "Database error", http.StatusInternalServerError)
		return
	}

	http.Redirect(w, r, "/admin?status=uploaded", http.StatusSeeOther)
}

func handleDelete(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	id := r.FormValue("id")
	if id == "" {
		http.Error(w, "No ID provided", http.StatusBadRequest)
		return
	}

	form, err := getFormByID(id)
	if err != nil {
		http.Error(w, "Form not found", http.StatusNotFound)
		return
	}

	os.Remove(form.PDFPath)
	_, err = db.Exec("DELETE FROM forms WHERE id = ?", form.ID)
	if err != nil {
		http.Error(w, "Database error", http.StatusInternalServerError)
		return
	}

	http.Redirect(w, r, "/admin?status=deleted", http.StatusSeeOther)
}

func handleConvert(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	id := r.FormValue("id")
	if id == "" {
		http.Error(w, "No ID provided", http.StatusBadRequest)
		return
	}

	form, err := getFormByID(id)
	if err != nil {
		http.Error(w, "Form not found", http.StatusNotFound)
		return
	}

	if _, err := exec.LookPath("pdftk"); err != nil {
		http.Error(w, "pdftk is not installed", http.StatusServiceUnavailable)
		return
	}

	// Extract form fields from PDF
	fields, err := extractPDFFields(form.PDFPath)
	if err != nil {
		http.Error(w, fmt.Sprintf("Failed to extract form fields: %v", err), http.StatusInternalServerError)
		return
	}

	if len(fields) == 0 {
		http.Error(w, "No form fields found in PDF", http.StatusBadRequest)
		return
	}

	apiKey := os.Getenv("OPENAI_API_KEY")
	if apiKey == "" {
		http.Error(w, "OPENAI_API_KEY environment variable is not set", http.StatusServiceUnavailable)
		return
	}

	apiURL := os.Getenv("OPENAI_API_URL")
	if apiURL == "" {
		apiURL = "https://api.openai.com/v1/chat/completions"
	}

	model := os.Getenv("OPENAI_MODEL")
	if model == "" {
		model = "gpt-4o"
	}

	// Convert PDF pages to images
	imageURIs, err := pdfToImages(form.PDFPath)
	if err != nil {
		http.Error(w, fmt.Sprintf("Failed to process PDF: %v", err), http.StatusInternalServerError)
		return
	}

	// Build the field mapping and prompt
	fieldMap := buildFieldMapping(fields)
	mappingJSON, _ := json.Marshal(fieldMap)

	// Build a table for the prompt
	var tableRows []string
	for i, m := range fieldMap {
		typeLabel := m.Type
		if m.Type == "Button" {
			typeLabel = "checkbox"
		} else if m.Type == "Text" || m.Type == "" {
			typeLabel = "text"
		} else if m.Type == "Signature" {
			typeLabel = "text"
		}
		tableRows = append(tableRows,
			fmt.Sprintf("  %d. name=\"%s\"  type=\"%s\"  (PDF field: \"%s\")",
				i+1, m.HTMLName, typeLabel, m.PDFName))
	}
	tableStr := strings.Join(tableRows, "\n")

		prompt := fmt.Sprintf(`You are a PDF form to HTML converter. I've attached a PDF form document.

You must generate a complete, self-contained HTML file that replicates this PDF form as a MULTI-STEP WIZARD.

FIELD MAPPING - You MUST use these EXACT "name" attribute values:
%s

CRITICAL RULES:
1. Generate a SINGLE complete HTML document (<!DOCTYPE html> through </html>)
2. Use inline CSS for all styling
3. Use inline JavaScript for step navigation (no external libraries)
4. Organize the fields into logical STEPS (3-8 steps) based on the PDF sections
5. Use the EXACT name attribute values shown above (e.g. name="telephone_number")
6. For checkboxes (type="checkbox"), use <input type="checkbox" name="...">
7. For text fields, use <input type="text" name="...">
8. Add clear labels for every field based on what you see in the PDF
9. The form should POST to "/form/%d" with method="post" and enctype="multipart/form-data"
10. Do NOT include any markdown code fences - output raw HTML only
11. Use a clean, professional design
12. Do NOT add any hidden input fields - they will be added automatically
13. ADA COMPLIANCE: every <input> must be wrapped in a <label> or paired with <label for="...">. For checkbox groups with shared category labels, wrap the label text before the input.

WIZARD STRUCTURE:
- Wrap all fields in a single <form> element
- Each step is a <div class="form-step" data-step="N"> where N is the step number
- Only one step is visible at a time (use CSS display:none for hidden steps)
- Show a progress bar at the top: "Step X of Y - [Step Title]"
- Each step has "Previous" and "Next" buttons (first step has only "Next", last step has "Submit")
- Validate visible fields before allowing "Next" — show inline error messages for empty required fields
- The "Submit" button on the final step actually submits the form

JAVASCRIPT REQUIREMENTS:
- Include a <script> tag with functions: showStep(n), nextStep(), prevStep(), validateStep()
- Use data attributes to track the current step
- Smooth transitions between steps (fade in/out)
- Mark required fields with an asterisk (*)
- The Previous button should always work without validation

PROGRESS BAR:
- Horizontal bar with step indicators (circles connected by lines)
- Clickable step indicators that jump to that step
- Active step highlighted, completed steps marked as done
- Step labels underneath each indicator

STEPS SHOULD GROUP RELATED FIELDS:
- Look at the PDF visually to determine natural section breaks
- Group checkboxes that belong together on the same step
- Put signature/name fields on the final step before submission

Generate the complete HTML wizard form now:`, tableStr, form.ID)

	// Call LLM
	htmlContent, err := callLLMWithPDF(apiURL, apiKey, model, prompt, imageURIs)
	if err != nil {
		http.Error(w, fmt.Sprintf("LLM conversion failed: %v", err), http.StatusInternalServerError)
		return
	}

	// Clean up HTML
	htmlContent = cleanHTML(htmlContent)

	// Second LLM pass: identify text-typed fields that should be checkboxes
	// Many PDFs have fields that look like checkboxes but are typed as "Text"
	pseudoCheckboxes, err := detectPseudoCheckboxes(apiURL, apiKey, model, fields, fieldMap, imageURIs)
	if err != nil {
		log.Printf("[convert form=%d] Pseudo-checkbox detection failed, continuing: %v", form.ID, err)
	} else {
		log.Printf("[convert form=%d] Detected %d pseudo-checkbox fields", form.ID, len(pseudoCheckboxes))
		for _, pc := range pseudoCheckboxes {
			for i := range fieldMap {
				if fieldMap[i].HTMLName == pc {
					fieldMap[i].PseudoCheckbox = true
					break
				}
			}
		}
	}

	// Post-process: detect "Other" + "Other Specify" pairs
	// The "Other" checkbox is often missed by the LLM; pair it with its text input
	detectOtherSpecifyPairs(fields, fieldMap)

	// Fix element types based on our authoritative field mapping
	// LLM often generates wrong input types (text instead of checkbox or vice versa)
	htmlContent = fixInputTypes(htmlContent, fieldMap)

	// Fix labels for ADA compliance: add id to inputs, for to labels
	htmlContent = fixLabels(htmlContent, fieldMap)

	// Inject JS for "Other Specify" auto-check behavior
	htmlContent = injectSpecifyJS(htmlContent)

	// Always inject the field mapping (LLM often produces broken HTML for it)
	mappingJSON, _ = json.Marshal(fieldMap)
	htmlContent = injectFieldMapping(htmlContent, string(mappingJSON))

	// Save to database
	_, err = db.Exec("UPDATE forms SET html_content = ?, field_meta = ? WHERE id = ?",
		htmlContent, mappingJSON, form.ID)
	if err != nil {
		http.Error(w, "Failed to save converted form", http.StatusInternalServerError)
		return
	}

	http.Redirect(w, r, fmt.Sprintf("/admin?status=converted&id=%d", form.ID), http.StatusSeeOther)
}

// ---- PUBLIC FORM HANDLERS ----

func handleForm(w http.ResponseWriter, r *http.Request) {
	formID := strings.TrimPrefix(r.URL.Path, "/form/")
	if formID == "" || formID == "/" {
		http.NotFound(w, r)
		return
	}

	form, err := getFormByID(formID)
	if err != nil {
		http.Error(w, "Form not found", http.StatusNotFound)
		return
	}

	if form.HTMLContent == "" {
		http.Error(w, "This form has not been converted yet", http.StatusServiceUnavailable)
		return
	}

	switch r.Method {
	case http.MethodGet:
		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		w.Write([]byte(form.HTMLContent))

	case http.MethodPost:
		fillPDF(w, r, form)
	}
}

func fillPDF(w http.ResponseWriter, r *http.Request, form *Form) {
	if err := r.ParseMultipartForm(maxUpload); err != nil {
		http.Error(w, "Form parsing error", http.StatusBadRequest)
		return
	}

	// Get field mapping from hidden field
	mappingStr := r.FormValue("_field_map")
	var mapping []FieldMapping

	if mappingStr == "" && form.FieldMeta != "" {
		mappingStr = form.FieldMeta
	}

	if mappingStr == "" {
		log.Printf("[fillPDF form=%d] No field mapping found", form.ID)
		http.Error(w, "Missing field mapping", http.StatusBadRequest)
		return
	}

	if err := json.Unmarshal([]byte(mappingStr), &mapping); err != nil {
		log.Printf("[fillPDF form=%d] Invalid mapping JSON: %v, raw=%q", form.ID, err, mappingStr[:min(len(mappingStr), 200)])
		http.Error(w, "Invalid field mapping", http.StatusBadRequest)
		return
	}

	// Build reverse map: html_name -> pdf_name
	htmlToPDF := make(map[string]string)
	// Build set of pseudo-checkbox PDF field names (text fields that should behave as checkboxes)
	pseudoCheckboxFields := make(map[string]bool)
	// Build specify->checkbox mapping: html_name of specify text input -> html_name of other checkbox
	specifyToOtherHtml := make(map[string]string)
	for _, m := range mapping {
		htmlToPDF[m.HTMLName] = m.PDFName
		if m.PseudoCheckbox {
			pseudoCheckboxFields[m.PDFName] = true
		}
		if m.CheckboxField != "" {
			specifyToOtherHtml[m.HTMLName] = m.CheckboxField
		}
	}

	// Re-extract PDF fields to get actual types (stored type may be empty)
	pdfFields, err := extractPDFFields(form.PDFPath)
	if err != nil {
		log.Printf("[fillPDF form=%d] Failed to extract PDF fields: %v", form.ID, err)
	}

	// Build set of button/checkbox PDF field names
	// Use options as the signal: checkboxes have [Off, Yes] (or similar pairs)
	buttonFields := make(map[string]bool)
	for _, f := range pdfFields {
		if len(f.Options) >= 2 || strings.EqualFold(f.Type, "Button") {
			buttonFields[f.Name] = true
		}
	}

	log.Printf("[fillPDF form=%d] Button fields (%d): %v", form.ID, len(buttonFields), getBoolMapKeys(buttonFields))

	// Collect all submitted field names (take only first value per field to avoid duplicates)
	submittedNames := make(map[string]string)
	for htmlName, values := range r.MultipartForm.Value {
		if htmlName == "_field_map" {
			continue
		}
		submittedNames[htmlName] = values[0]
	}

	log.Printf("[fillPDF form=%d] Submitted fields (%d): %v", form.ID, len(submittedNames), getMapKeys(submittedNames))
	log.Printf("[fillPDF form=%d] Mapping keys (%d): %v", form.ID, len(htmlToPDF), getMapKeys(htmlToPDF))

	// Map submitted values to exact PDF field names
	pdfData := make(map[string]string)
	unmapped := []string{}
	for htmlName, value := range submittedNames {
		pdfName, ok := htmlToPDF[htmlName]
		if !ok {
			pdfName = findClosestPDFField(htmlName, htmlToPDF)
		}
		if pdfName != "" {
			pdfData[pdfName] = value
		} else {
			unmapped = append(unmapped, fmt.Sprintf("%s=%q", htmlName, value))
		}
	}

	if len(unmapped) > 0 {
		log.Printf("[fillPDF form=%d] UNMAPPED fields: %v", form.ID, unmapped)
	}

	// Handle checkboxes: "on" -> "Yes", absent -> "Off"
	for pdfName := range buttonFields {
		if val, exists := pdfData[pdfName]; exists {
			if strings.ToLower(val) == "on" {
				pdfData[pdfName] = "Yes"
			}
		} else {
			pdfData[pdfName] = "Off"
		}
	}

	// Handle pseudo-checkboxes: text fields that behave as checkboxes
	// When checked ("on") -> write "X", when absent -> don't write anything (leave empty)
	for pdfName := range pseudoCheckboxFields {
		if val, exists := pdfData[pdfName]; exists {
			if strings.ToLower(val) == "on" {
				pdfData[pdfName] = "X"
			}
		} else {
			delete(pdfData, pdfName)
		}
	}

	// Handle "Other Specify" auto-check: if a specify text field has a value,
	// auto-check its paired "Other" pseudo-checkbox
	for specifyHtmlName, otherHtmlName := range specifyToOtherHtml {
		specifyPdfName := htmlToPDF[specifyHtmlName]
		otherPdfName := htmlToPDF[otherHtmlName]
		specifyVal, hasValue := pdfData[specifyPdfName]
		if hasValue && strings.TrimSpace(specifyVal) != "" && otherPdfName != "" {
			pdfData[otherPdfName] = "X"
			log.Printf("[fillPDF form=%d] Auto-checked Other checkbox %q because specify field %q has value", form.ID, otherPdfName, specifyHtmlName)
		}
	}

	log.Printf("[fillPDF form=%d] PDF data (%d fields): %v", form.ID, len(pdfData), getMapKeys(pdfData))
	log.Printf("[fillPDF form=%d] Button fields: %v", form.ID, getBoolMapKeys(buttonFields))
	log.Printf("[fillPDF form=%d] Pseudo-checkbox fields: %v", form.ID, getBoolMapKeys(pseudoCheckboxFields))

	// Create FDF and fill PDF
	fdfPath, err := createFDF(pdfData)
	if err != nil {
		http.Error(w, fmt.Sprintf("Failed to prepare PDF: %v", err), http.StatusInternalServerError)
		return
	}
	defer os.Remove(fdfPath)

	outputPath := filepath.Join(pdfDir, fmt.Sprintf("filled_%d_%d.pdf", form.ID, time.Now().Unix()))
	defer os.Remove(outputPath)

	cmd := exec.Command("pdftk", form.PDFPath, "fill_form", fdfPath, "output", outputPath)
	if output, err := cmd.CombinedOutput(); err != nil {
		log.Printf("[fillPDF form=%d] pdftk error: %v, output: %s", form.ID, err, string(output))
		http.Error(w, fmt.Sprintf("Failed to fill PDF: %v", err), http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/pdf")
	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s_filled.pdf", form.Name))
	http.ServeFile(w, r, outputPath)
}

func getMapKeys(m map[string]string) []string {
	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	return keys
}

func getBoolMapKeys(m map[string]bool) []string {
	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	return keys
}

// ---- PDF UTILITIES ----

func extractPDFFields(pdfPath string) ([]PDFField, error) {
	cmd := exec.Command("pdftk", pdfPath, "dump_data_fields", "output", "-")
	output, err := cmd.Output()
	if err != nil {
		return nil, fmt.Errorf("pdftk failed: %v", err)
	}

	fields := []PDFField{}
	var current *PDFField
	var pendingOptions []string
	var pendingType string // FieldType can come BEFORE FieldName

	lines := strings.Split(string(output), "\n")
	for _, line := range lines {
		line = strings.TrimSpace(line)
		if line == "" || strings.HasPrefix(line, "%") {
			continue
		}

		if strings.HasPrefix(line, "---") {
			// End of previous field block
			if current != nil {
				current.Options = append(current.Options, pendingOptions...)
				fields = append(fields, *current)
			}
			current = nil
			pendingOptions = nil
			pendingType = ""
			continue
		}

		if strings.HasPrefix(line, "FieldType:") {
			pendingType = strings.TrimSpace(strings.TrimPrefix(line, "FieldType:"))
			continue
		}

		if strings.HasPrefix(line, "FieldName:") {
			current = &PDFField{
				Name: strings.TrimSpace(strings.TrimPrefix(line, "FieldName:")),
				Type: pendingType,
			}
			pendingType = ""
			pendingOptions = nil
			continue
		}

		if current == nil {
			continue
		}

		if strings.HasPrefix(line, "FieldFlags:") {
			flags := strings.TrimSpace(strings.TrimPrefix(line, "FieldFlags:"))
			current.Required = strings.Contains(strings.ToLower(flags), "required")
		} else if strings.HasPrefix(line, "FieldNameAlt:") {
			current.Alt = strings.TrimSpace(strings.TrimPrefix(line, "FieldNameAlt:"))
		} else if strings.HasPrefix(line, "FieldStateOption:") {
			pendingOptions = append(pendingOptions, strings.TrimSpace(strings.TrimPrefix(line, "FieldStateOption:")))
		} else if strings.HasPrefix(line, "FieldMaxLength:") {
			val := strings.TrimSpace(strings.TrimPrefix(line, "FieldMaxLength:"))
			current.MaxLength, _ = fmt.Sscanf(val, "%d", &current.MaxLength)
		} else if strings.HasPrefix(line, "FieldContent:") {
			current.DefaultValue = strings.TrimSpace(strings.TrimPrefix(line, "FieldContent:"))
		}
	}

	// Flush last field
	if current != nil {
		current.Options = append(current.Options, pendingOptions...)
		fields = append(fields, *current)
	}

	return fields, nil
}

func createFDF(formData map[string]string) (string, error) {
	var sb strings.Builder
	sb.WriteString("%FDF-1.2\n")
	sb.WriteString("1 0 obj\n<< /FDF << /Fields [")

	for name, value := range formData {
		escaped := strings.ReplaceAll(value, "\\", "\\\\")
		escaped = strings.ReplaceAll(escaped, ")", "\\)")
		escaped = strings.ReplaceAll(escaped, "(", "\\(")
		escapedName := strings.ReplaceAll(name, "\\", "\\\\")
		escapedName = strings.ReplaceAll(escapedName, ")", "\\)")
		escapedName = strings.ReplaceAll(escapedName, "(", "\\(")
		sb.WriteString(fmt.Sprintf("<< /T (%s) /V (%s) >> ", escapedName, escaped))
	}

	sb.WriteString("] >> >>\nendobj\ntrailer\n<< /Root 1 0 R >>\n%%EOF")

	fdfPath := filepath.Join(pdfDir, fmt.Sprintf("temp_%d.fdf", time.Now().UnixNano()))
	if err := os.WriteFile(fdfPath, []byte(sb.String()), 0644); err != nil {
		return "", err
	}

	return fdfPath, nil
}

// ---- FIELD MAPPING ----

func buildFieldMapping(fields []PDFField) []FieldMapping {
	mapping := make([]FieldMapping, 0, len(fields))
	usedNames := make(map[string]bool)

	for _, f := range fields {
		safeName := toSafeHTMLName(f.Name)
		suffix := 1
		for usedNames[safeName] {
			safeName = toSafeHTMLName(f.Name) + fmt.Sprintf("_%d", suffix)
			suffix++
		}
		usedNames[safeName] = true

		mapping = append(mapping, FieldMapping{
			HTMLName: safeName,
			PDFName:  f.Name,
			Type:     f.Type,
		})
	}

	return mapping
}

func toSafeHTMLName(name string) string {
	var b strings.Builder
	prevSpace := false
	for _, r := range name {
		if r == ' ' || r == '-' || r == '/' {
			if !prevSpace {
				b.WriteRune('_')
				prevSpace = true
			}
		} else {
			b.WriteRune(unicode.ToLower(r))
			prevSpace = false
		}
	}
	return b.String()
}

func findClosestPDFField(htmlName string, htmlToPDF map[string]string) string {
	// Direct match
	if pdfName, ok := htmlToPDF[htmlName]; ok {
		return pdfName
	}

	// Case-insensitive match
	for h, pdf := range htmlToPDF {
		if strings.EqualFold(h, htmlName) {
			return pdf
		}
	}

	return ""
}

func injectFieldMapping(html, mappingJSON string) string {
	escapedJSON := strings.ReplaceAll(mappingJSON, "'", "&#39;")
	hiddenField := fmt.Sprintf(`<input type="hidden" name="_field_map" value='%s'>`, escapedJSON)

	// Remove any existing (possibly broken) _field_map hidden fields
	re := regexp.MustCompile(`(?is)<input[^>]*name="_field_map"[^>]*/?>`)
	html = re.ReplaceAllString(html, "")

	// Inject before </form>
	html = regexp.MustCompile(`(?i)</form>`).ReplaceAllString(html, hiddenField+"\n</form>")
	return html
}

func fixInputTypes(html string, mapping []FieldMapping) string {
	for _, m := range mapping {
		isButton := strings.EqualFold(m.Type, "Button")
		isPseudoCheckbox := m.PseudoCheckbox
		name := regexp.QuoteMeta(m.HTMLName)
		desiredType := "text"
		if isButton || isPseudoCheckbox {
			desiredType = "checkbox"
		}
		hasCheckboxField := m.CheckboxField != ""

		// Find all inputs with this name and fix their type
		re := regexp.MustCompile(fmt.Sprintf(`(<input\s+)([^>]*?)name=["']%s["']([^>]*?)>`, name))
		html = re.ReplaceAllStringFunc(html, func(match string) string {
			// Check current type
			if strings.Contains(match, `type="`+desiredType+`"`) && !hasCheckboxField {
				return match // already correct
			}
			// Remove any existing type attribute and set the correct one
			match = regexp.MustCompile(`\s*type=["'][^"']*["']`).ReplaceAllString(match, "")
			// Insert type="checkbox" or type="text" right after <input
			match = regexp.MustCompile(`<input\s+`).ReplaceAllString(match, fmt.Sprintf(`<input type="%s" `, desiredType))

			// Add data-checkbox-field attribute to "Other specify" text inputs
			if hasCheckboxField && !strings.Contains(match, "data-checkbox-field") {
				match = regexp.MustCompile(`(<input\s+)`).ReplaceAllString(match, fmt.Sprintf(`${1}data-checkbox-field="%s" `, m.CheckboxField))
			}

			return match
		})
	}
	return html
}

// ---- LLM SERVICE ----

func pdfToImages(pdfPath string) ([]string, error) {
	if _, err := exec.LookPath("pdftoppm"); err != nil {
		return nil, fmt.Errorf("pdftoppm not found")
	}

	tmpDir, err := os.MkdirTemp("", "pdfimg")
	if err != nil {
		return nil, err
	}
	defer os.RemoveAll(tmpDir)

	cmd := exec.Command("pdftoppm", "-png", "-r", "150", pdfPath, filepath.Join(tmpDir, "page"))
	if out, err := cmd.CombinedOutput(); err != nil {
		return nil, fmt.Errorf("pdftoppm failed: %v: %s", err, string(out))
	}

	files, err := filepath.Glob(filepath.Join(tmpDir, "page-*.png"))
	if err != nil || len(files) == 0 {
		return nil, fmt.Errorf("no pages generated from PDF")
	}

	sort.Strings(files)

	imgs := []string{}
	for _, f := range files {
		data, err := os.ReadFile(f)
		if err != nil {
			continue
		}
		b64 := base64.StdEncoding.EncodeToString(data)
		imgs = append(imgs, "data:image/png;base64,"+b64)
	}

	return imgs, nil
}

func callLLMWithPDF(apiURL, apiKey, model, prompt string, imageURIs []string) (string, error) {
	contentParts := []map[string]interface{}{
		{"type": "text", "text": prompt},
	}

	for _, uri := range imageURIs {
		contentParts = append(contentParts, map[string]interface{}{
			"type": "image_url",
			"image_url": map[string]interface{}{"url": uri, "detail": "high"},
		})
	}

	payload := map[string]interface{}{
		"model": model,
		"messages": []map[string]interface{}{
			{"role": "system", "content": "You are a helpful assistant that generates clean, complete HTML."},
			{"role": "user", "content": contentParts},
		},
		"temperature":           0.1,
		"max_completion_tokens": 16384,
	}

	body, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	req, err := http.NewRequest("POST", apiURL, strings.NewReader(string(body)))
	if err != nil {
		return "", err
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+apiKey)

	client := &http.Client{Timeout: 180 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		respBody, _ := io.ReadAll(resp.Body)
		return "", fmt.Errorf("LLM API returned %d: %s", resp.StatusCode, string(respBody))
	}

	var result struct {
		Choices []struct {
			Message struct {
				Content string `json:"content"`
			} `json:"message"`
		} `json:"choices"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return "", err
	}

	if len(result.Choices) == 0 {
		return "", fmt.Errorf("no response from LLM")
	}

	return result.Choices[0].Message.Content, nil
}

// detectPseudoCheckboxes asks the LLM to identify text-typed fields that should be checkboxes
func detectPseudoCheckboxes(apiURL, apiKey, model string, pdfFields []PDFField, fieldMap []FieldMapping, imageURIs []string) ([]string, error) {
	// Build list of text-typed fields (these are the candidates)
	var candidates []string
	for _, m := range fieldMap {
		if m.Type == "Text" || m.Type == "" {
			candidates = append(candidates, fmt.Sprintf("  - html_name=\"%s\"  pdf_name=\"%s\"  alt=\"%s\"",
				m.HTMLName, m.PDFName, findFieldAlt(m.PDFName, pdfFields)))
		}
	}
	if len(candidates) == 0 {
		return nil, nil
	}

	candidateList := strings.Join(candidates, "\n")

	prompt := fmt.Sprintf(`You are analyzing a PDF form. Some fields are typed as "Text" in the PDF but should visually be checkboxes.

Here are the TEXT-TYPED fields (candidates for checkbox reclassification):

%s

Look at the attached PDF images and identify which of these fields are VISUALLY CHECKBOXES (have a checkbox next to their label).

Consider these clues:
- Field names that are category labels (e.g. "Dissolution of Marriage", "Paternity", "Custody") are often checkboxes
- Fields with names that are statements the user agrees to (e.g. "pending case involves same parties") are often checkboxes
- Fields in groups where the already-detected checkboxes appear are likely also checkboxes
- A field named "Other" (without "specify" in the name) that is followed by an "Other {specify" or "Other: specify" field IS a checkbox - it represents checking the "Other" option while the specify field is where the user writes in the detail
- Fields with names like "Other {specify", "Other: specify" are NOT checkboxes — they're text fields for writing in a custom value
- Fields that look like data entry areas (longer text fields) are NOT checkboxes — they are text inputs

Output ONLY a JSON array of html_name values that should be checkboxes. Example:
["dissolution_of_marriage", "paternity", "custody", "other"]

If none are checkboxes, output: []`, candidateList)

	contentParts := []map[string]interface{}{
		{"type": "text", "text": prompt},
	}

	for _, uri := range imageURIs {
		contentParts = append(contentParts, map[string]interface{}{
			"type": "image_url",
			"image_url": map[string]interface{}{"url": uri, "detail": "high"},
		})
	}

	payload := map[string]interface{}{
		"model": model,
		"messages": []map[string]interface{}{
			{"role": "system", "content": "You are a form analysis assistant. Output only valid JSON arrays."},
			{"role": "user", "content": contentParts},
		},
		"temperature":           0.0,
		"max_completion_tokens": 2048,
	}

	body, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", apiURL, strings.NewReader(string(body)))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+apiKey)

	client := &http.Client{Timeout: 120 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		respBody, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("LLM API returned %d: %s", resp.StatusCode, string(respBody))
	}

	var result struct {
		Choices []struct {
			Message struct {
				Content string `json:"content"`
			} `json:"message"`
		} `json:"choices"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return nil, err
	}

	if len(result.Choices) == 0 {
		return nil, fmt.Errorf("no response from LLM")
	}

	// Parse the JSON array from the response
	content := cleanHTML(result.Choices[0].Message.Content)

	// Find JSON array in the response
	start := strings.Index(content, "[")
	end := strings.LastIndex(content, "]")
	if start == -1 || end == -1 || end <= start {
		return nil, nil
	}

	var pseudoCheckboxes []string
	jsonStr := content[start : end+1]
	if err := json.Unmarshal([]byte(jsonStr), &pseudoCheckboxes); err != nil {
		log.Printf("[detectPseudoCheckboxes] Failed to parse JSON: %v, raw=%q", err, jsonStr[:min(len(jsonStr), 200)])
		return nil, nil
	}

	return pseudoCheckboxes, nil
}

func findFieldAlt(pdfName string, fields []PDFField) string {
	for _, f := range fields {
		if f.Name == pdfName {
			return f.Alt
		}
	}
	return ""
}

// detectOtherSpecifyPairs finds "Other" + "Other Specify" pairs and marks them
// The "Other" field is the pseudo-checkbox, "Other Specify" is the text input
func detectOtherSpecifyPairs(pdfFields []PDFField, fieldMap []FieldMapping) {
	specifyFields := make(map[string]int) // html_name -> index in fieldMap

	// First pass: find all "specify" text fields
	for i, m := range fieldMap {
		pdfName := strings.ToLower(m.PDFName)
		alt := strings.ToLower(findFieldAlt(m.PDFName, pdfFields))
		if strings.Contains(pdfName, "specify") || strings.Contains(alt, "specify") {
			if m.Type == "Text" || m.Type == "" {
				specifyFields[m.HTMLName] = i
			}
		}
	}

	// Second pass: for each "specify" field, find its paired "Other" pseudo-checkbox
	// Try exact base match first, then try matching with numeric suffixes
	for _, specifyIdx := range specifyFields {
		specifyPdf := strings.ToLower(fieldMap[specifyIdx].PDFName)
		specifyAlt := strings.ToLower(findFieldAlt(fieldMap[specifyIdx].PDFName, pdfFields))

		// Extract base name and numeric suffix
		basePdf, suffixNum := splitBaseSuffix(specifyPdf)
		baseAlt, _ := splitBaseSuffix(specifyAlt)

		// Find matching "Other" checkbox field (try with suffix first for uniqueness)
		found := false
		for i, m := range fieldMap {
			pdfName := strings.ToLower(m.PDFName)
			if strings.Contains(pdfName, "specify") {
				continue
			}

			// Try base + suffix match first (e.g., "other_2" matches "other specify_2")
			if suffixNum > 0 && pdfName == basePdf+"_"+fmt.Sprint(suffixNum) {
				fieldMap[i].PseudoCheckbox = true
				fieldMap[specifyIdx].CheckboxField = m.HTMLName
				found = true
				break
			}
			// Then try exact base match
			if suffixNum == 0 && (pdfName == basePdf || pdfName == baseAlt) {
				fieldMap[i].PseudoCheckbox = true
				fieldMap[specifyIdx].CheckboxField = m.HTMLName
				found = true
				break
			}
		}

		if !found && basePdf != "" {
			// Fallback: match on base without suffix
			for i, m := range fieldMap {
				pdfName := strings.ToLower(m.PDFName)
				if strings.Contains(pdfName, "specify") {
					continue
				}
				if pdfName == basePdf || pdfName == baseAlt {
					fieldMap[i].PseudoCheckbox = true
					fieldMap[specifyIdx].CheckboxField = m.HTMLName
					log.Printf("[detectOtherSpecifyPairs] Paired %q (checkbox) with %q (specify)", m.PDFName, fieldMap[specifyIdx].PDFName)
					found = true
					break
				}
			}
		}
		_ = found
	}
}

// splitBaseSuffix extracts the base name and numeric suffix from a field name
// e.g., "other specify_2" -> ("other", 2), "dissolution_of_marriage" -> ("dissolution_of_marriage", 0)
func splitBaseSuffix(s string) (string, int) {
	s = strings.ReplaceAll(s, "specify", "")
	s = strings.ReplaceAll(s, "{", "")
	s = strings.ReplaceAll(s, "}", "")
	s = strings.ReplaceAll(s, ":", "")
	s = strings.TrimSpace(s)

	// Check for trailing _N pattern
	if idx := strings.LastIndex(s, "_"); idx > 0 {
		numStr := s[idx+1:]
		var num int
		if _, err := fmt.Sscanf(numStr, "%d", &num); err == nil && num > 0 {
			base := strings.TrimSuffix(s[:idx], "_")
			base = strings.TrimSpace(base)
			return base, num
		}
	}

	return s, 0
}

// stripSpecifySuffix removes "specify", braces, colons, and numeric suffixes from a field name
func stripSpecifySuffix(s string) string {
	s = strings.ReplaceAll(s, "specify", "")
	s = strings.ReplaceAll(s, "{", "")
	s = strings.ReplaceAll(s, "}", "")
	s = strings.ReplaceAll(s, ":", "")
	// Strip trailing "_2", "_3", etc. (numeric suffixes from field deduplication)
	s = strings.TrimSuffix(s, "_")
	// Also strip any remaining numeric suffix
	for strings.HasSuffix(s, "_") || (len(s) > 0 && s[len(s)-1] >= '0' && s[len(s)-1] <= '9') {
		if strings.HasSuffix(s, "_") {
			s = strings.TrimSuffix(s, "_")
		} else {
			s = s[:len(s)-1]
		}
	}
	s = strings.TrimSpace(s)
	s = strings.TrimSuffix(s, "_")
	return s
}

// fixLabels ensures every input has an id attribute and every label has a for attribute (ADA compliance)
func fixLabels(html string, mapping []FieldMapping) string {
	// Step 1: Ensure every input has an id matching its name
	// Handle name="..." and name='...'
	nameRe := regexp.MustCompile(`<input([^>]*)name=["']([^"']+)["']([^>]*)>`)
	html = nameRe.ReplaceAllStringFunc(html, func(match string) string {
		// Extract attributes before and after name
		nameIdx := strings.Index(match, `name=`)
		if nameIdx == -1 {
			return match
		}
		before := match[:nameIdx]
		nameIdx2 := strings.Index(match[nameIdx:], `"`)
		if nameIdx2 == -1 {
			return match
		}
		endQuote := strings.LastIndex(match, `"`)
		if endQuote == -1 {
			endQuote = strings.LastIndex(match, `'`)
		}
		if endQuote == -1 {
			return match
		}
		nameVal := match[nameIdx+6 : endQuote]
		after := match[endQuote+1:]

		// Check if id attribute already exists
		if strings.Contains(before, `id=`) || strings.Contains(after, `id=`) {
			return match
		}

		// Add id attribute before the name attribute
		before = regexp.MustCompile(`(<input\s+)`).ReplaceAllString(before, `${1}id="`+nameVal+`" `)
		return before + match[nameIdx:]
	})

	// Step 2: For each label without a for attribute, add for="..." pointing to the nearest input
	// Strategy: find <label>...</label> blocks, check if they contain an input or have a for attribute
	html = fixLabelForAttributes(html, mapping)

	return html
}

func fixLabelForAttributes(html string, mapping []FieldMapping) string {
	// Find all label blocks
	labelRe := regexp.MustCompile(`(?is)<label([^>]*)>(.*?)</label>`)
	html = labelRe.ReplaceAllStringFunc(html, func(match string) string {
		// Extract label attributes and content
		labelOpen := regexp.MustCompile(`(?is)<label([^>]*)>`).FindStringSubmatch(match)
		if labelOpen == nil {
			return match
		}

		labelAttrs := labelOpen[1]
		content := regexp.MustCompile(`(?is)>(.*?)</label>`).FindStringSubmatch(match)
		if content == nil {
			return match
		}
		labelContent := content[1]

		// If label already has a for attribute, leave it
		if strings.Contains(strings.ToLower(labelAttrs), `for=`) {
			return match
		}

		// Try to find an input's name/id within the label content
		inputNameRe := regexp.MustCompile(`name=["']([^"']+)["']`)
		nameMatch := inputNameRe.FindStringSubmatch(labelContent)
		if nameMatch != nil {
			inputName := nameMatch[1]
			labelAttrs = strings.TrimSpace(labelAttrs)
			if labelAttrs == "" {
				labelAttrs = fmt.Sprintf(` for="%s"`, inputName)
			} else {
				labelAttrs = fmt.Sprintf(`%s for="%s"`, labelAttrs, inputName)
			}
			return fmt.Sprintf("<label%s>%s</label>", labelAttrs, labelContent)
		}

		// Try to find an id attribute on an input within the label
		inputIdRe := regexp.MustCompile(`id=["']([^"']+)["']`)
		idMatch := inputIdRe.FindStringSubmatch(labelContent)
		if idMatch != nil {
			inputID := idMatch[1]
			labelAttrs = strings.TrimSpace(labelAttrs)
			if labelAttrs == "" {
				labelAttrs = fmt.Sprintf(` for="%s"`, inputID)
			} else {
				labelAttrs = fmt.Sprintf(`%s for="%s"`, labelAttrs, inputID)
			}
			return fmt.Sprintf("<label%s>%s</label>", labelAttrs, labelContent)
		}

		return match
	})

	return html
}

// injectSpecifyJS adds JavaScript to auto-check "Other" checkbox when its paired "Other Specify" text field gets input
func injectSpecifyJS(html string) string {
	js := `<script>
(function(){
document.querySelectorAll('input[type="text"][data-checkbox-field]').forEach(function(textInput){
var checkboxName = textInput.getAttribute('data-checkbox-field');
var cb = document.querySelector('input[name="'+checkboxName+'"]');
if(cb){
textInput.addEventListener('input',function(){cb.checked=this.value.trim()!=='';});
textInput.addEventListener('change',function(){cb.checked=this.value.trim()!=='';});
}
});
})();
</script>`

	// Inject before </body>, or if no body, before </html>
	if strings.Contains(strings.ToLower(html), "</body>") {
		html = strings.Replace(html, "</body>", js+"\n</body>", 1)
	} else if strings.Contains(strings.ToLower(html), "</html>") {
		html = strings.Replace(html, "</html>", js+"\n</html>", 1)
	} else {
		html += js
	}

	return html
}

// ---- HELPERS ----

func getForms() ([]Form, error) {
	rows, err := db.Query("SELECT id, name, pdf_path, html_content, field_meta, created_at FROM forms ORDER BY created_at DESC")
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	forms := []Form{}
	for rows.Next() {
		var f Form
		if err := rows.Scan(&f.ID, &f.Name, &f.PDFPath, &f.HTMLContent, &f.FieldMeta, &f.CreatedAt); err != nil {
			return nil, err
		}
		forms = append(forms, f)
	}
	return forms, rows.Err()
}

func getFormByID(id string) (*Form, error) {
	var f Form
	err := db.QueryRow("SELECT id, name, pdf_path, html_content, field_meta, created_at FROM forms WHERE id = ?", id).
		Scan(&f.ID, &f.Name, &f.PDFPath, &f.HTMLContent, &f.FieldMeta, &f.CreatedAt)
	if err != nil {
		return nil, err
	}
	return &f, nil
}

func cleanHTML(html string) string {
	html = strings.ReplaceAll(html, "```html", "")
	html = strings.ReplaceAll(html, "```", "")
	html = strings.TrimSpace(html)
	return html
}