package main

import (
	"embed"
	"fmt"
	"log"
	"mime"
	"net/http"
	"path"
	"path/filepath"
	"regexp"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/glebarez/sqlite"
	"github.com/google/uuid"
	"gorm.io/gorm"
)

func serveStaticFile(c *gin.Context, prefix string) error {
	cleanPath := path.Clean(c.Request.URL.Path)
	if cleanPath == "/" {
		cleanPath = "/index.html"
	}

	// Try to read the exact file first
	content, err := frontend.ReadFile(prefix + cleanPath)
	ext := strings.ToLower(filepath.Ext(cleanPath))

	// If file not found OR the path has no extension (likely a route path), serve index.html
	if err != nil || ext == "" {
		content, err = frontend.ReadFile(prefix + "/index.html")
		if err != nil {
			return err
		}
		c.Header("Content-Type", "text/html; charset=utf-8")
		// Add security headers for HTML content
		c.Header("X-Content-Type-Options", "nosniff")
		c.Data(http.StatusOK, "text/html; charset=utf-8", content)
		return nil
	}

	// For actual files, set the correct MIME type
	var mimeType string
	switch ext {
	case ".js":
		mimeType = "application/javascript; charset=utf-8"
	case ".css":
		mimeType = "text/css; charset=utf-8"
	case ".html":
		mimeType = "text/html; charset=utf-8"
	case ".json":
		mimeType = "application/json; charset=utf-8"
	case ".png":
		mimeType = "image/png"
	case ".svg":
		mimeType = "image/svg+xml"
	default:
		mimeType = mime.TypeByExtension(ext)
		if mimeType == "" {
			// Try to detect content type from the content itself
			mimeType = http.DetectContentType(content)
		}
	}

	// Set security headers for all responses
	c.Header("X-Content-Type-Options", "nosniff")
	c.Data(http.StatusOK, mimeType, content)
	return nil
}

//go:embed frontend/build/* frontend/static/*
var frontend embed.FS

type Note struct {
	ID        string    `json:"id" gorm:"primaryKey"`
	Title     string    `json:"title" gorm:"not null"`
	Content   string    `json:"content" gorm:"not null"`
	CreatedAt time.Time `json:"createdAt"`
	UpdatedAt time.Time `json:"updatedAt"`
	// Link relationships
	LinksTo   []*Note   `json:"linksTo,omitempty" gorm:"many2many:note_links;joinForeignKey:source_note_id;joinReferences:target_note_id"`
	LinkedBy  []*Note   `json:"linkedBy,omitempty" gorm:"many2many:note_links;joinForeignKey:target_note_id;joinReferences:source_note_id"`
}

// Link represents a connection between two notes
type NoteLink struct {
	SourceNoteID string    `gorm:"primaryKey"`
	TargetNoteID string    `gorm:"primaryKey"`
	CreatedAt    time.Time `gorm:"autoCreateTime"`
}

// ExtractLinks finds all [[note-title]] style links in the content
func (n *Note) ExtractLinks(content string) []string {
	re := regexp.MustCompile(`\[\[(.*?)\]\]`)
	matches := re.FindAllStringSubmatch(content, -1)
	titles := make([]string, 0, len(matches))
	for _, match := range matches {
		if len(match) > 1 {
			titles = append(titles, match[1])
		}
	}
	return titles
}

// UpdateLinks updates the note's links based on its content
func (n *Note) UpdateLinks(db *gorm.DB) error {
	// Start a transaction
	tx := db.Begin()
	if tx.Error != nil {
		return fmt.Errorf("failed to start transaction: %w", tx.Error)
	}
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// Delete existing links
	if err := tx.Where("source_note_id = ?", n.ID).Delete(&NoteLink{}).Error; err != nil {
		tx.Rollback()
		return fmt.Errorf("failed to delete existing links: %w", err)
	}

	// Extract and create new links
	titles := n.ExtractLinks(n.Content)
	for _, title := range titles {
		var target Note
		if err := tx.Where("title = ?", title).First(&target).Error; err != nil {
			if err == gorm.ErrRecordNotFound {
				// Skip non-existent notes
				continue
			}
			tx.Rollback()
			return fmt.Errorf("failed to find target note %q: %w", title, err)
		}

		link := NoteLink{
			SourceNoteID: n.ID,
			TargetNoteID: target.ID,
		}
		if err := tx.Create(&link).Error; err != nil {
			tx.Rollback()
			return fmt.Errorf("failed to create link to %q: %w", title, err)
		}
	}

	return tx.Commit().Error
}

var db *gorm.DB

func main() {
	var err error
	db, err = gorm.Open(sqlite.Open("notes.db"), &gorm.Config{})
	if err != nil {
		log.Fatal(err)
	}

	// Auto migrate the schema
	if err := db.AutoMigrate(&Note{}); err != nil {
		log.Fatal(err)
	}

	// Create Gin router
	r := gin.Default()

	// API routes
	api := r.Group("/api")
	{
		notes := api.Group("/notes")
		{
			notes.GET("", handleGetNotes)
			notes.POST("", handleCreateNote)
			notes.GET("/:id", handleGetNote)
			notes.PUT("/:id", handleUpdateNote)
			notes.DELETE("/:id", handleDeleteNote)
		}

		api.POST("/test/reset", handleReset)
	}

	// Serve frontend
	r.NoRoute(handleFrontend)

	log.Printf("INFO: Server starting on http://localhost:3000")
	log.Fatal(r.Run(":3000"))
}

func handleGetNotes(c *gin.Context) {
	var notes []Note
	if err := db.Preload("LinksTo").Order("updated_at desc").Find(&notes).Error; err != nil {
		log.Printf("ERROR: Failed to query notes: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, notes)
}

func handleCreateNote(c *gin.Context) {
	var note Note
	if err := c.ShouldBindJSON(&note); err != nil {
		log.Printf("ERROR: Failed to decode note: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// Generate a new UUID for the note
	note.ID = uuid.New().String()

	// Start a transaction
	tx := db.Begin()
	if tx.Error != nil {
		log.Printf("ERROR: Failed to start transaction: %v", tx.Error)
		c.JSON(http.StatusInternalServerError, gin.H{"error": tx.Error.Error()})
		return
	}
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// Create the note
	if err := tx.Create(&note).Error; err != nil {
		tx.Rollback()
		log.Printf("ERROR: Failed to create note: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	// Update links
	if err := note.UpdateLinks(tx); err != nil {
		tx.Rollback()
		log.Printf("ERROR: Failed to update note links: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	if err := tx.Commit().Error; err != nil {
		log.Printf("ERROR: Failed to commit transaction: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	// Load the note with its relationships
	if err := db.Preload("LinksTo").First(&note).Error; err != nil {
		log.Printf("ERROR: Failed to load note relationships: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusCreated, note)
}

func handleGetNote(c *gin.Context) {
	id := c.Param("id")
	var note Note

	if err := db.Preload("LinksTo").Preload("LinkedBy").First(&note, "id = ?", id).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			c.Status(http.StatusNotFound)
			return
		}
		log.Printf("ERROR: Failed to get note %s: %v", id, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, note)
}

func handleUpdateNote(c *gin.Context) {
	id := c.Param("id")
	var note Note

	if err := c.ShouldBindJSON(&note); err != nil {
		log.Printf("ERROR: Failed to decode note update: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// Start a transaction
	tx := db.Begin()
	if tx.Error != nil {
		log.Printf("ERROR: Failed to start transaction: %v", tx.Error)
		c.JSON(http.StatusInternalServerError, gin.H{"error": tx.Error.Error()})
		return
	}
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// Update the note
	if err := tx.Model(&Note{}).Where("id = ?", id).Updates(map[string]interface{}{
		"title":      note.Title,
		"content":    note.Content,
		"updated_at": note.UpdatedAt,
	}).Error; err != nil {
		tx.Rollback()
		log.Printf("ERROR: Failed to update note %s: %v", id, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	// Load the updated note for link processing
	if err := tx.First(&note, "id = ?", id).Error; err != nil {
		tx.Rollback()
		log.Printf("ERROR: Failed to load note %s: %v", id, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	// Update links
	if err := note.UpdateLinks(tx); err != nil {
		tx.Rollback()
		log.Printf("ERROR: Failed to update note links: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	if err := tx.Commit().Error; err != nil {
		log.Printf("ERROR: Failed to commit transaction: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.Status(http.StatusOK)
}

func handleDeleteNote(c *gin.Context) {
	id := c.Param("id")

	if err := db.Delete(&Note{}, "id = ?", id).Error; err != nil {
		log.Printf("ERROR: Failed to delete note %s: %v", id, err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.Status(http.StatusNoContent)
}

func handleReset(c *gin.Context) {
	if err := db.Session(&gorm.Session{AllowGlobalUpdate: true}).Delete(&Note{}).Error; err != nil {
		log.Printf("ERROR: Failed to reset database: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	c.Status(http.StatusOK)
}

func handleFrontend(c *gin.Context) {
	// Don't serve API routes
	if path.Dir(c.Request.URL.Path) == "/api" {
		c.Status(http.StatusNotFound)
		return
	}

	err := serveStaticFile(c, "frontend/build")
	if err != nil { // if serveStaticFile returns an error, it has already tried to serve index.html as fallback
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
	}
}