package readlist

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

// Handler handles HTTP requests for read later items
type Handler struct {
	service *Service
}

// NewHandler creates a new read later handler
func NewHandler(service *Service) *Handler {
	return &Handler{service: service}
}

// RegisterRoutes registers the read later routes with the given router group
func (h *Handler) RegisterRoutes(group *gin.RouterGroup) {
	readlist := group.Group("/readlist")
	{
		readlist.GET("", h.handleList)
		readlist.POST("", h.handleCreate)
		readlist.GET("/:id", h.handleGet)
		readlist.POST("/:id/read", h.handleMarkRead)
		readlist.POST("/:id/archive", h.handleArchive)
		readlist.POST("/:id/unarchive", h.handleUnarchive)
		readlist.DELETE("/:id", h.handleDelete)
		readlist.POST("/import/shiori", h.handleImportFromShiori)
		readlist.GET("/import/status/:id", h.handleImportStatus)
	}

	// Test endpoint
	group.POST("/test/readlist/reset", h.handleReset)
}

func (h *Handler) handleList(c *gin.Context) {
	includeArchived := c.Query("includeArchived") == "true"
	items, err := h.service.List(includeArchived)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, items)
}

func (h *Handler) handleCreate(c *gin.Context) {
	var req struct {
		URL string `json:"url" binding:"required"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	item, err := h.service.Create(req.URL)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, item)
}

func (h *Handler) handleGet(c *gin.Context) {
	id := c.Param("id")
	item, err := h.service.Get(id)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	if item == nil {
		c.Status(http.StatusNotFound)
		return
	}

	c.JSON(http.StatusOK, item)
}

func (h *Handler) handleMarkRead(c *gin.Context) {
	id := c.Param("id")
	if err := h.service.MarkRead(id); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.Status(http.StatusOK)
}

func (h *Handler) handleDelete(c *gin.Context) {
	id := c.Param("id")
	if err := h.service.Delete(id); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.Status(http.StatusOK)
}

func (h *Handler) handleReset(c *gin.Context) {
	if err := h.service.Reset(); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	c.Status(http.StatusOK)
}

func (h *Handler) handleArchive(c *gin.Context) {
	id := c.Param("id")
	if err := h.service.Archive(id); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.Status(http.StatusOK)
}

func (h *Handler) handleUnarchive(c *gin.Context) {
	id := c.Param("id")
	if err := h.service.Unarchive(id); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.Status(http.StatusOK)
}

// handleImportFromShiori handles importing bookmarks from a Shiori instance
func (h *Handler) handleImportFromShiori(c *gin.Context) {
	var creds ShioriCredentials
	if err := c.ShouldBindJSON(&creds); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// Validate required fields
	if creds.URL == "" || creds.Username == "" || creds.Password == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "URL, username, and password are required"})
		return
	}

	// Start the import process
	importID, err := h.service.ImportFromShiori(creds)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	// Return the import ID
	c.JSON(http.StatusAccepted, gin.H{"importId": importID})
}

// handleImportStatus handles getting the status of an import operation
func (h *Handler) handleImportStatus(c *gin.Context) {
	importID := c.Param("id")
	if importID == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Import ID is required"})
		return
	}

	// Get import status
	status, exists := h.service.GetImportStatus(importID)
	if !exists {
		c.JSON(http.StatusNotFound, gin.H{"error": "Import not found"})
		return
	}

	// Return the status
	c.JSON(http.StatusOK, status)
}