core/server/handlers/attachments.go

package handlers

import (
	"context"
	"fmt"
	"io"
	"log"
	"net/http"
	"path/filepath"
	"strings"
	"time"

	"github.com/gin-gonic/gin"

	"git.gobha.me/xcaliber/chat-switchboard/database"
	"git.gobha.me/xcaliber/chat-switchboard/extraction"
	"git.gobha.me/xcaliber/chat-switchboard/models"
	"git.gobha.me/xcaliber/chat-switchboard/storage"
	"git.gobha.me/xcaliber/chat-switchboard/store"
)

// ── Default Limits ─────────────────────────
// Overridable via global_settings keys.
const (
	defaultMaxFileSize          = 10 * 1024 * 1024 // 10 MB
	defaultMaxUploadSize        = 50 * 1024 * 1024 // 50 MB total per request (future: multi-file)
	defaultMaxAttachmentsPerMsg = 5                 // future: multi-file per message
	defaultOrphanMaxAge         = 24 * time.Hour
)

// allowedMIMETypes is the default allowlist. Admin can override via global_settings.
var allowedMIMETypes = map[string]bool{
	// Images
	"image/jpeg": true, "image/png": true, "image/gif": true,
	"image/webp": true, "image/svg+xml": true,
	// Documents
	"application/pdf": true,
	"text/plain": true, "text/markdown": true, "text/csv": true,
	// Microsoft Office
	"application/vnd.openxmlformats-officedocument.wordprocessingml.document":   true,
	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":         true,
	"application/vnd.openxmlformats-officedocument.presentationml.presentation": true,
	"application/msword": true, "application/vnd.ms-excel": true,
	// OpenDocument
	"application/vnd.oasis.opendocument.text":         true,
	"application/vnd.oasis.opendocument.spreadsheet":  true,
	"application/vnd.oasis.opendocument.presentation": true,
	// Other
	"application/rtf": true,
}

// ── Handler ────────────────────────────────

type AttachmentHandler struct {
	stores   store.Stores
	objStore storage.ObjectStore
	extQueue *extraction.Queue // nil if extraction disabled
}

func NewAttachmentHandler(stores store.Stores, objStore storage.ObjectStore, extQueue *extraction.Queue) *AttachmentHandler {
	return &AttachmentHandler{stores: stores, objStore: objStore, extQueue: extQueue}
}

// ── Upload ─────────────────────────────────
// POST /api/v1/channels/:id/attachments
// Multipart form: file field "file", returns attachment metadata.
func (h *AttachmentHandler) Upload(c *gin.Context) {
	if h.objStore == nil {
		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "file storage not configured"})
		return
	}

	userID := getUserID(c)
	channelID := c.Param("id")

	// Verify channel ownership
	if !h.verifyChannelAccess(c, channelID, userID) {
		return
	}

	// Parse multipart
	file, header, err := c.Request.FormFile("file")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "missing file field"})
		return
	}
	defer file.Close()

	// Size check
	if header.Size > defaultMaxFileSize {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": fmt.Sprintf("file too large (max %d MB)", defaultMaxFileSize/(1024*1024)),
		})
		return
	}

	// MIME detection: read first 512 bytes for sniffing, then reset
	buf := make([]byte, 512)
	n, _ := file.Read(buf)
	detectedType := http.DetectContentType(buf[:n])

	// Reset reader to start
	if _, err := file.Seek(0, io.SeekStart); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to process file"})
		return
	}

	// Normalize MIME type (strip params like charset)
	contentType := detectedType
	if idx := strings.Index(contentType, ";"); idx > 0 {
		contentType = strings.TrimSpace(contentType[:idx])
	}

	// For types that DetectContentType can't distinguish (returns application/octet-stream),
	// fall back to extension-based detection
	if contentType == "application/octet-stream" {
		ext := strings.ToLower(filepath.Ext(header.Filename))
		if mapped, ok := extToMIME[ext]; ok {
			contentType = mapped
		}
	}

	// Allowlist check
	if !allowedMIMETypes[contentType] {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": fmt.Sprintf("file type %q not allowed", contentType),
		})
		return
	}

	// Build storage key: attachments/{channel_id}/{attachment_id}_{filename}
	// We generate the ID first via a temp UUID, then use it in the key.
	att := &models.Attachment{
		ChannelID:   channelID,
		UserID:      userID,
		Filename:    sanitizeFilename(header.Filename),
		ContentType: contentType,
		SizeBytes:   header.Size,
		Metadata: models.JSONMap{
			"extraction_status": "pending",
		},
	}

	// Create PG row first to get the UUID
	// storage_key is set after we have the ID
	att.StorageKey = "placeholder"
	if err := h.stores.Attachments.Create(c.Request.Context(), att); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create attachment record"})
		return
	}

	// Now build the real storage key and update
	att.StorageKey = fmt.Sprintf("attachments/%s/%s_%s", channelID, att.ID, att.Filename)

	// Write to object store
	if err := h.objStore.Put(c.Request.Context(), att.StorageKey, file, header.Size, contentType); err != nil {
		// Rollback PG row on storage failure
		h.stores.Attachments.Delete(c.Request.Context(), att.ID)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to store file"})
		return
	}

	// Update storage_key in PG
	database.DB.ExecContext(c.Request.Context(),
		database.Q(`UPDATE attachments SET storage_key = $1 WHERE id = $2`),
		att.StorageKey, att.ID)

	// For images, mark extraction as not needed (complete immediately)
	if strings.HasPrefix(contentType, "image/") {
		h.stores.Attachments.UpdateMetadata(c.Request.Context(), att.ID, map[string]interface{}{
			"extraction_status": "complete",
		})
		att.Metadata["extraction_status"] = "complete"
	}

	// For text/plain, extract inline (trivial — just read the file)
	if contentType == "text/plain" || contentType == "text/markdown" || contentType == "text/csv" {
		if _, err := file.Seek(0, io.SeekStart); err == nil {
			if textBytes, err := io.ReadAll(file); err == nil {
				text := string(textBytes)
				h.stores.Attachments.SetExtractedText(c.Request.Context(), att.ID, text)
				h.stores.Attachments.UpdateMetadata(c.Request.Context(), att.ID, map[string]interface{}{
					"extraction_status": "complete",
				})
				att.Metadata["extraction_status"] = "complete"
			}
		}
	}

	// For documents requiring extraction (PDF, DOCX, etc.), enqueue for sidecar
	if extraction.IsExtractable(contentType) && h.extQueue != nil {
		if err := h.extQueue.Enqueue(att.ID, att.StorageKey, contentType, att.Filename); err != nil {
			log.Printf("extraction enqueue failed for %s: %v", att.ID, err)
			// Non-fatal: file is uploaded, just won't have extracted text
		}
	}

	c.JSON(http.StatusCreated, att)
}

// ── Download ───────────────────────────────
// GET /api/v1/attachments/:id/download
// Streams file content with auth check via channel membership.
func (h *AttachmentHandler) Download(c *gin.Context) {
	if h.objStore == nil {
		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "file storage not configured"})
		return
	}

	userID := getUserID(c)
	attID := c.Param("id")

	att, err := h.stores.Attachments.GetByID(c.Request.Context(), attID)
	if err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "attachment not found"})
		return
	}

	// Channel-scoped access check
	if !h.verifyChannelAccess(c, att.ChannelID, userID) {
		return
	}

	reader, size, _, err := h.objStore.Get(c.Request.Context(), att.StorageKey)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to read file"})
		return
	}
	defer reader.Close()

	c.Header("Content-Type", att.ContentType)
	c.Header("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, att.Filename))
	c.Header("Content-Length", fmt.Sprintf("%d", size))
	c.Status(http.StatusOK)
	io.Copy(c.Writer, reader)
}

// ── Get Metadata ───────────────────────────
// GET /api/v1/attachments/:id
func (h *AttachmentHandler) GetMetadata(c *gin.Context) {
	userID := getUserID(c)
	attID := c.Param("id")

	att, err := h.stores.Attachments.GetByID(c.Request.Context(), attID)
	if err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "attachment not found"})
		return
	}

	if !h.verifyChannelAccess(c, att.ChannelID, userID) {
		return
	}

	c.JSON(http.StatusOK, att)
}

// ── List Channel Attachments ───────────────
// GET /api/v1/channels/:id/attachments
func (h *AttachmentHandler) ListByChannel(c *gin.Context) {
	userID := getUserID(c)
	channelID := c.Param("id")

	if !h.verifyChannelAccess(c, channelID, userID) {
		return
	}

	attachments, err := h.stores.Attachments.GetByChannel(c.Request.Context(), channelID)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list attachments"})
		return
	}
	if attachments == nil {
		attachments = []models.Attachment{}
	}

	c.JSON(http.StatusOK, gin.H{"attachments": attachments})
}

// ── Delete ─────────────────────────────────
// DELETE /api/v1/attachments/:id
func (h *AttachmentHandler) DeleteAttachment(c *gin.Context) {
	userID := getUserID(c)
	attID := c.Param("id")

	att, err := h.stores.Attachments.GetByID(c.Request.Context(), attID)
	if err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "attachment not found"})
		return
	}

	if !h.verifyChannelAccess(c, att.ChannelID, userID) {
		return
	}

	// Delete from PG (returns the row for storage cleanup)
	deleted, err := h.stores.Attachments.Delete(c.Request.Context(), attID)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete attachment"})
		return
	}

	// Clean up storage (async-safe: fire and forget with background context)
	if h.objStore != nil && deleted != nil {
		storageKey := deleted.StorageKey
		go func() {
			ctx := context.Background()
			if err := h.objStore.Delete(ctx, storageKey); err != nil {
				log.Printf("storage cleanup failed for %s: %v", storageKey, err)
			}
			// Also clean up thumbnail if it exists
			h.objStore.Delete(ctx, storageKey+"_thumb.jpg")
		}()
	}

	c.JSON(http.StatusOK, gin.H{"message": "attachment deleted"})
}

// ── Admin: Orphan Cleanup ──────────────────
// POST /admin/storage/cleanup
func (h *AttachmentHandler) CleanupOrphans(c *gin.Context) {
	orphans, err := h.stores.Attachments.ListOrphans(c.Request.Context(), defaultOrphanMaxAge)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list orphans"})
		return
	}

	deleted := 0
	var freedBytes int64

	for _, att := range orphans {
		if _, err := h.stores.Attachments.Delete(c.Request.Context(), att.ID); err != nil {
			log.Printf("orphan cleanup: failed to delete %s from PG: %v", att.ID, err)
			continue
		}
		if h.objStore != nil {
			h.objStore.Delete(c.Request.Context(), att.StorageKey)
			h.objStore.Delete(c.Request.Context(), att.StorageKey+"_thumb.jpg")
		}
		deleted++
		freedBytes += att.SizeBytes
	}

	c.JSON(http.StatusOK, gin.H{
		"deleted":     deleted,
		"freed_bytes": freedBytes,
		"scanned":     len(orphans),
	})
}

// ── Admin: Orphan Count ────────────────────
// GET /admin/storage/orphans (for the admin panel card)
func (h *AttachmentHandler) OrphanCount(c *gin.Context) {
	orphans, err := h.stores.Attachments.ListOrphans(c.Request.Context(), defaultOrphanMaxAge)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to count orphans"})
		return
	}

	var totalBytes int64
	for _, att := range orphans {
		totalBytes += att.SizeBytes
	}

	c.JSON(http.StatusOK, gin.H{
		"count":             len(orphans),
		"reclaimable_bytes": totalBytes,
	})
}

// ── Admin: Extraction Queue Status ─────────
// GET /admin/storage/extraction
func (h *AttachmentHandler) ExtractionStatus(c *gin.Context) {
	if h.extQueue == nil {
		c.JSON(http.StatusOK, gin.H{
			"enabled": false,
			"items":   []interface{}{},
		})
		return
	}

	items, err := h.extQueue.ListAll()
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list extraction queue"})
		return
	}
	if items == nil {
		items = []extraction.QueueItem{}
	}

	// Count by status
	counts := map[string]int{}
	for _, item := range items {
		counts[item.Status]++
	}

	c.JSON(http.StatusOK, gin.H{
		"enabled": true,
		"total":   len(items),
		"counts":  counts,
		"items":   items,
	})
}

// ── Channel Delete Hook ────────────────────
// Called by ChannelHandler.DeleteChannel to clean up storage.
func (h *AttachmentHandler) CleanupChannelStorage(channelID string) {
	if h.objStore == nil {
		return
	}
	// CASCADE already deleted PG rows. Clean up filesystem.
	prefix := fmt.Sprintf("attachments/%s", channelID)
	if err := h.objStore.DeletePrefix(context.Background(), prefix); err != nil {
		log.Printf("storage cleanup for channel %s failed: %v", channelID, err)
	}
}

// ── Helpers ────────────────────────────────

// verifyChannelAccess checks that the requesting user owns the channel.
// Future RBAC (v0.20.0): replace with rbac.Can(userID, channelID, permission).
func (h *AttachmentHandler) verifyChannelAccess(c *gin.Context, channelID, userID string) bool {
	var ownerID string
	err := database.DB.QueryRowContext(c.Request.Context(),
		database.Q(`SELECT user_id FROM channels WHERE id = $1`), channelID).Scan(&ownerID)
	if err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "channel not found"})
		return false
	}
	if ownerID != userID {
		// Check if user is admin (admins can access any channel)
		role, _ := c.Get("role")
		if role != "admin" {
			c.JSON(http.StatusForbidden, gin.H{"error": "access denied"})
			return false
		}
	}
	return true
}

// sanitizeFilename cleans a filename for safe storage.
func sanitizeFilename(name string) string {
	// Take only the base name (strip path separators)
	name = filepath.Base(name)
	// Replace problematic characters
	replacer := strings.NewReplacer(
		"/", "_", "\\", "_", "..", "_", "\x00", "",
	)
	name = replacer.Replace(name)
	if name == "" || name == "." {
		name = "unnamed"
	}
	// Truncate to 200 chars (leave room for UUID prefix in storage key)
	if len(name) > 200 {
		ext := filepath.Ext(name)
		name = name[:200-len(ext)] + ext
	}
	return name
}

// extToMIME maps file extensions to MIME types for cases where
// http.DetectContentType returns application/octet-stream.
var extToMIME = map[string]string{
	".pdf":  "application/pdf",
	".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
	".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
	".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
	".doc":  "application/msword",
	".xls":  "application/vnd.ms-excel",
	".odt":  "application/vnd.oasis.opendocument.text",
	".ods":  "application/vnd.oasis.opendocument.spreadsheet",
	".odp":  "application/vnd.oasis.opendocument.presentation",
	".rtf":  "application/rtf",
	".md":   "text/markdown",
	".csv":  "text/csv",
	".svg":  "image/svg+xml",
}