package api

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"

	"git.pengzhan.dev/haopengzhan/rsspipe/internal/db"
	"git.pengzhan.dev/haopengzhan/rsspipe/internal/models"
	"git.pengzhan.dev/haopengzhan/rsspipe/internal/services"
	"github.com/go-chi/chi/v5"
)

// Entry Handlers
func (h *Handler) ListEntries(w http.ResponseWriter, r *http.Request) {
	q := r.URL.Query()
	limit, _ := strconv.Atoi(q.Get("limit"))
	offset, _ := strconv.Atoi(q.Get("offset"))

	filter := db.EntryFilter{
		View:       q.Get("view"),
		FeedID:     q.Get("feed_id"),
		CategoryID: q.Get("category_id"),
		Search:     q.Get("search"),
		Limit:      limit,
		Offset:     offset,
	}

	entries, total, err := h.entryService.ListEntries(r.Context(), filter)
	if err != nil {
		h.writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	if entries == nil {
		entries = []models.FeedEntry{}
	}

	h.writeJSON(w, http.StatusOK, map[string]interface{}{
		"entries": entries,
		"total":   total,
		"limit":   limit,
		"offset":  offset,
	})
}

func (h *Handler) GetEntry(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")
	entry, err := h.entryService.GetEntry(r.Context(), id)
	if err != nil {
		if err == sql.ErrNoRows {
			h.writeError(w, http.StatusNotFound, "entry not found")
			return
		}
		h.writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	h.writeJSON(w, http.StatusOK, entry)
}

// PatchEntry handles atomic partial updates to an entry and returns the updated entry + transition diff
func (h *Handler) PatchEntry(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")
	var req models.PatchEntryRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		h.writeError(w, http.StatusBadRequest, "invalid request body")
		return
	}

	updated, diff, err := h.entryService.PatchEntry(r.Context(), id, req)
	if err != nil {
		h.writeError(w, http.StatusInternalServerError, err.Error())
		return
	}

	h.writeJSON(w, http.StatusOK, map[string]interface{}{
		"entry": updated,
		"diff":  diff,
	})
}

func (h *Handler) UpdateEntryRead(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")
	var body models.UpdateEntryReadRequest
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		h.writeError(w, http.StatusBadRequest, "invalid body")
		return
	}

	updated, _, err := h.entryService.PatchEntry(r.Context(), id, models.PatchEntryRequest{
		IsRead: &body.IsRead,
	})
	if err != nil {
		h.writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	h.writeJSON(w, http.StatusOK, map[string]interface{}{"id": id, "is_read": updated.IsRead})
}

func (h *Handler) UpdateEntryStar(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")
	var body models.UpdateEntryStarRequest
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		h.writeError(w, http.StatusBadRequest, "invalid body")
		return
	}

	updated, _, err := h.entryService.PatchEntry(r.Context(), id, models.PatchEntryRequest{
		IsStarred: &body.IsStarred,
	})
	if err != nil {
		h.writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	h.writeJSON(w, http.StatusOK, map[string]interface{}{"id": id, "is_starred": updated.IsStarred})
}

func (h *Handler) MarkAllRead(w http.ResponseWriter, r *http.Request) {
	var body models.MarkAllReadRequest
	_ = json.NewDecoder(r.Body).Decode(&body)

	if err := h.entryService.MarkAllRead(r.Context(), body.FeedID, body.CategoryID); err != nil {
		h.writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	h.writeJSON(w, http.StatusOK, map[string]string{"message": "marked all as read"})
}

// ScrapeEntry triggers readability full text extraction (immediate response for UI, async if ?async=true)
func (h *Handler) ScrapeEntry(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")
	entry, err := h.entryService.GetEntry(r.Context(), id)
	if err != nil {
		h.writeError(w, http.StatusNotFound, "entry not found")
		return
	}

	idempotencyKey := services.GenerateIdempotencyKey("readability_scrape", id, "manual", entry.CreatedAt.Format("20060102150405"))
	job, err := h.jobService.Enqueue(r.Context(), "readability_scrape", map[string]interface{}{
		"entry_id": id,
		"url":      entry.URL,
	}, idempotencyKey)
	if err != nil {
		h.writeError(w, http.StatusInternalServerError, err.Error())
		return
	}

	if r.URL.Query().Get("async") == "true" {
		h.writeJSON(w, http.StatusAccepted, map[string]interface{}{
			"job_id":  job.ID,
			"status":  job.Status,
			"message": "Scrape task queued asynchronously",
		})
		return
	}

	if h.jobEngine == nil {
		h.writeError(w, http.StatusInternalServerError, "job engine not initialized")
		return
	}

	patch, result, err := h.jobEngine.ExecuteDirect(r.Context(), "readability_scrape", job.Payload)
	if err != nil {
		h.writeError(w, http.StatusInternalServerError, fmt.Sprintf("scraping failed: %v", err))
		return
	}

	if patch != nil {
		updated, _, patchErr := h.entryService.PatchEntry(r.Context(), id, *patch)
		if patchErr != nil {
			h.writeError(w, http.StatusInternalServerError, patchErr.Error())
			return
		}
		_ = h.db.UpdateJob(models.Job{
			ID:       job.ID,
			Status:   "completed",
			Progress: 100,
			Result:   result,
		})
		h.writeJSON(w, http.StatusOK, updated)
		return
	}

	updated, _ := h.entryService.GetEntry(r.Context(), id)
	h.writeJSON(w, http.StatusOK, updated)
}

// GenerateAISummary generates an AI summary (immediate response for UI, async if ?async=true)
func (h *Handler) GenerateAISummary(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")
	entry, err := h.entryService.GetEntry(r.Context(), id)
	if err != nil {
		h.writeError(w, http.StatusNotFound, "entry not found")
		return
	}

	var body struct {
		Prompt string `json:"prompt,omitempty"`
	}
	_ = json.NewDecoder(r.Body).Decode(&body)

	idempotencyKey := services.GenerateIdempotencyKey("ai_summary", id, "manual", entry.CreatedAt.Format("20060102150405"))
	job, err := h.jobService.Enqueue(r.Context(), "ai_summary", map[string]interface{}{
		"entry_id": id,
		"prompt":   body.Prompt,
	}, idempotencyKey)
	if err != nil {
		h.writeError(w, http.StatusInternalServerError, err.Error())
		return
	}

	if r.URL.Query().Get("async") == "true" {
		h.writeJSON(w, http.StatusAccepted, map[string]interface{}{
			"job_id":  job.ID,
			"status":  job.Status,
			"message": "AI summary task queued asynchronously",
		})
		return
	}

	if h.jobEngine == nil {
		h.writeError(w, http.StatusInternalServerError, "job engine not initialized")
		return
	}

	patch, result, err := h.jobEngine.ExecuteDirect(r.Context(), "ai_summary", job.Payload)
	if err != nil {
		h.writeError(w, http.StatusInternalServerError, fmt.Sprintf("AI summary generation failed: %v", err))
		return
	}

	if patch != nil {
		updated, _, patchErr := h.entryService.PatchEntry(r.Context(), id, *patch)
		if patchErr != nil {
			h.writeError(w, http.StatusInternalServerError, patchErr.Error())
			return
		}
		_ = h.db.UpdateJob(models.Job{
			ID:       job.ID,
			Status:   "completed",
			Progress: 100,
			Result:   result,
		})
		h.writeJSON(w, http.StatusOK, updated)
		return
	}

	updated, _ := h.entryService.GetEntry(r.Context(), id)
	h.writeJSON(w, http.StatusOK, updated)
}

func (h *Handler) ToggleShareEntry(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")
	shareUUID, err := h.entryService.ToggleShare(r.Context(), id)
	if err != nil {
		h.writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	entry, _ := h.entryService.GetEntry(r.Context(), id)
	h.writeJSON(w, http.StatusOK, map[string]interface{}{
		"shared":     shareUUID != nil,
		"share_uuid": shareUUID,
		"entry":      entry,
	})
}

func (h *Handler) ListEntryVariants(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")
	variants, err := h.db.ListVariantsForEntry(id)
	if err != nil {
		h.writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	h.writeJSON(w, http.StatusOK, variants)
}

func (h *Handler) GetVariantBlobStream(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")
	key := chi.URLParam(r, "key")
	variant, err := h.db.GetVariant(id, key)
	if err != nil {
		h.writeError(w, http.StatusNotFound, "variant not found")
		return
	}
	if variant.BlobPath == "" {
		h.writeError(w, http.StatusNotFound, "variant has no binary media blob")
		return
	}

	http.ServeFile(w, r, variant.BlobPath)
}

// ViewSharedEntry renders a styled standalone HTML page for an explicitly shared entry (strictly checked)
func (h *Handler) ViewSharedEntry(w http.ResponseWriter, r *http.Request) {
	uuidStr := chi.URLParam(r, "uuid")
	entry, err := h.entryService.GetSharedEntry(r.Context(), uuidStr)
	if err != nil {
		http.Error(w, "Shared article not found", http.StatusNotFound)
		return
	}

	// Render standalone styled HTML
	html := fmt.Sprintf(`<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>%s - RSSPipe</title>
    <style>
        :root { --bg: #0f172a; --card: #1e293b; --text: #f8fafc; --muted: #94a3b8; --accent: #38bdf8; }
        @media (prefers-color-scheme: light) {
            :root { --bg: #f8fafc; --card: #ffffff; --text: #0f172a; --muted: #64748b; --accent: #0284c7; }
        }
        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: var(--bg); color: var(--text); line-height: 1.7; margin: 0; padding: 2rem 1rem; display: flex; justify-content: center; }
        .container { max-width: 760px; width: 100%%; background: var(--card); border-radius: 12px; padding: 2.5rem; box-shadow: 0 10px 25px rgba(0,0,0,0.1); }
        .meta { color: var(--muted); font-size: 0.9rem; margin-bottom: 1.5rem; display: flex; flex-wrap: wrap; gap: 1rem; align-items: center; border-bottom: 1px solid rgba(148, 163, 184, 0.2); padding-bottom: 1rem; }
        h1 { margin-top: 0; font-size: 2rem; line-height: 1.3; }
        h1 a { color: inherit; text-decoration: none; }
        h1 a:hover { color: var(--accent); }
        .content img { max-width: 100%%; height: auto; border-radius: 8px; }
        .content pre { background: rgba(0,0,0,0.2); padding: 1rem; border-radius: 8px; overflow-x: auto; }
        .footer { margin-top: 2.5rem; padding-top: 1.5rem; border-top: 1px solid rgba(148, 163, 184, 0.2); font-size: 0.85rem; color: var(--muted); text-align: center; }
    </style>
</head>
<body>
    <div class="container">
        <div class="meta">
            <span><strong>%s</strong></span>
            <span>•</span>
            <span>%s</span>
            %s
        </div>
        <h1><a href="%s" target="_blank" rel="noopener noreferrer">%s ↗</a></h1>
        <div class="content">
            %s
        </div>
        <div class="footer">
            Shared via <a href="/" style="color: var(--accent); text-decoration: none;">RSSPipe Information Gateway</a>
        </div>
    </div>
</body>
</html>`,
		entry.Title,
		entry.FeedTitle,
		entry.PublishedAt.Format("Jan 02, 2006 15:04"),
		func() string {
			if entry.Author != "" {
				return "<span>•</span><span>By " + entry.Author + "</span>"
			}
			return ""
		}(),
		entry.URL,
		entry.Title,
		entry.Content,
	)

	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	_, _ = w.Write([]byte(html))
}