package article

import (
	"RenewCMS/api/pkg/apperr"
	"RenewCMS/api/pkg/claims"
	validator "RenewCMS/api/pkg/validator"
	domain "RenewCMS/internal/domain/article"
	"RenewCMS/internal/domain/author"
	"RenewCMS/internal/domain/image"
	"RenewCMS/internal/domain/site"
	"RenewCMS/internal/infrastructure/useCases"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"slices"
	"strconv"
	"strings"
	"time"

	"github.com/go-chi/chi/v5"
	playground "github.com/go-playground/validator/v10"
)

type Handler struct {
	CreateUseCase  *useCases.CreateArticleUseCase
	GetUseCase     *useCases.GetArticleUseCase
	ListUseCase    *useCases.ListArticlesUseCase
	DeleteUseCase  *useCases.DeleteArticleUseCase
	UpdateUseCase  *useCases.UpdateArticleUseCase
	GetUserUseCase *useCases.GetUserUseCase
}

type PostArticle struct {
	Title string `json:"title" validate:"required,min=3,max=200"`
	Body  string `json:"body"`
}

func NewHandler(create *useCases.CreateArticleUseCase, get *useCases.GetArticleUseCase, list *useCases.ListArticlesUseCase, delete *useCases.DeleteArticleUseCase, update *useCases.UpdateArticleUseCase, getUser *useCases.GetUserUseCase) *Handler {
	return &Handler{
		CreateUseCase:  create,
		GetUseCase:     get,
		ListUseCase:    list,
		DeleteUseCase:  delete,
		UpdateUseCase:  update,
		GetUserUseCase: getUser,
	}
}

type baseArticleResponse struct {
	ID         uint32            `json:"id"`
	Title      string            `json:"title"`
	Body       json.RawMessage   `json:"body"`
	BodyFormat domain.BodyFormat `json:"body_format"`
	IsOnline   bool              `json:"is_online"`
	SiteID     uint32            `json:"site_id"`
	Authors    []author.Byline   `json:"authors"`
	CreatedAt  time.Time         `json:"created_at"`
	UpdatedAt  time.Time         `json:"updated_at"`
}

type articleResponse struct {
	baseArticleResponse
	Slug              string   `json:"slug"`
	Excerpt           string   `json:"excerpt"`
	SEOTitle          string   `json:"seo_title"`
	SEODescription    string   `json:"seo_description"`
	CoverImageID      *uint32  `json:"cover_image_id"`
	CoverImageAlt     string   `json:"cover_image_alt"`
	SocialTitle       string   `json:"social_title"`
	SocialDescription string   `json:"social_description"`
	SocialImageID     *uint32  `json:"social_image_id"`
	CanonicalURL      string   `json:"canonical_url"`
	Noindex           bool     `json:"noindex"`
	SEODismissed      []string `json:"seo_dismissed"`
}

type listItemResponse struct {
	baseArticleResponse
	Excerpt        string `json:"excerpt"`
	Slug           string `json:"slug"`
	SEOStatus      string `json:"seo_status"`
	SEOSuggestions int    `json:"seo_suggestions"`
}

func toBaseResponse(article domain.Article, format domain.BodyFormat) (baseArticleResponse, error) {
	body := json.RawMessage(article.Body)
	if format != domain.BodyFormatJSON {
		encoded, err := json.Marshal(article.Body)
		if err != nil {
			return baseArticleResponse{}, err
		}
		body = encoded
	}
	authors := article.Authors
	if authors == nil {
		authors = []author.Byline{}
	}
	return baseArticleResponse{
		ID:         article.ID,
		Title:      article.Title,
		Body:       body,
		BodyFormat: format,
		IsOnline:   article.IsOnline,
		SiteID:     article.SiteID,
		Authors:    authors,
		CreatedAt:  article.CreatedAt,
		UpdatedAt:  article.UpdatedAt,
	}, nil
}

func toArticleResponse(article domain.Article, format domain.BodyFormat) (articleResponse, error) {
	base, err := toBaseResponse(article, format)
	if err != nil {
		return articleResponse{}, err
	}
	dismissed := article.SEODismissed
	if dismissed == nil {
		dismissed = []string{}
	}
	return articleResponse{
		baseArticleResponse: base,
		Slug:                article.Slug,
		Excerpt:             article.Excerpt,
		SEOTitle:            article.SEOTitle,
		SEODescription:      article.SEODescription,
		CoverImageID:        article.CoverImageID,
		CoverImageAlt:       article.CoverImageAlt,
		SocialTitle:         article.SocialTitle,
		SocialDescription:   article.SocialDescription,
		SocialImageID:       article.SocialImageID,
		CanonicalURL:        article.CanonicalURL,
		Noindex:             article.Noindex,
		SEODismissed:        dismissed,
	}, nil
}

func toListItemResponse(article domain.Article, summary domain.SEOSummary, format domain.BodyFormat) (listItemResponse, error) {
	base, err := toBaseResponse(article, format)
	if err != nil {
		return listItemResponse{}, err
	}
	return listItemResponse{baseArticleResponse: base, Excerpt: article.Excerpt, Slug: article.Slug, SEOStatus: summary.Status, SEOSuggestions: summary.Suggestions}, nil
}

func encodeArticle(article domain.Article, format domain.BodyFormat) ([]byte, error) {
	response, err := toArticleResponse(article, format)
	if err != nil {
		return nil, err
	}
	return json.Marshal(response)
}

func parseBodyFormat(w http.ResponseWriter, r *http.Request) (domain.BodyFormat, bool) {
	format, err := domain.ParseBodyFormat(r.URL.Query().Get("format"))
	if err != nil {
		http.Error(w, apperr.ArticleBodyFormatErrorMessage, http.StatusBadRequest)
		return "", false
	}
	return format, true
}

func parseArticleId(r *http.Request) (uint32, error) {
	id, err := strconv.ParseUint(chi.URLParam(r, "id"), 10, 32)
	return uint32(id), err
}

func (h *Handler) GetArticle(w http.ResponseWriter, r *http.Request) {
	id, err := parseArticleId(r)
	if err != nil {
		http.Error(w, apperr.IdUint32ErrorMessage, http.StatusBadRequest)
		return
	}

	format, ok := parseBodyFormat(w, r)
	if !ok {
		return
	}

	var article domain.Article
	if h.callerIsVerified(r) {
		article, err = h.GetUseCase.GetArticle(id, format)
	} else {
		article, err = h.GetUseCase.GetOnlineArticle(id, format)
	}
	if err != nil {
		if errors.Is(err, domain.ErrArticleNotFound) {
			http.Error(w, apperr.ArticleNotFoundErrorMessage, http.StatusNotFound)
			return
		}
		http.Error(w, "Internal server error", http.StatusInternalServerError)
		return
	}

	articleJson, err := encodeArticle(article, format)
	if err != nil {
		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
		return
	}

	if _, err := w.Write(articleJson); err != nil {
		fmt.Printf("Failed to write response: %v", err)
	}
}

func (h *Handler) PostArticle(w http.ResponseWriter, r *http.Request) {
	format, ok := parseBodyFormat(w, r)
	if !ok {
		return
	}

	var localArticle PostArticle
	if err := json.NewDecoder(r.Body).Decode(&localArticle); err != nil {
		http.Error(w, apperr.BodyErrorMessage, http.StatusBadRequest)
		return
	}

	if err := validator.Validate.Struct(localArticle); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	creatorId, _ := claims.UserId(r)
	createdArticle, err := h.CreateUseCase.CreateArticle(r.Context(), useCases.CreateArticleCommand{
		Title:     localArticle.Title,
		Body:      localArticle.Body,
		Format:    format,
		CreatedBy: creatorId,
	})
	if err != nil {
		if errors.Is(err, domain.ErrInvalidTitle) {
			http.Error(w, apperr.ArticleTitleErrorMessage, http.StatusBadRequest)
			return
		}
		if !writeKnownArticleError(w, err) {
			http.Error(w, "Failed to create article", http.StatusInternalServerError)
		}
		return
	}

	writeArticleJsonResponse(w, http.StatusCreated, createdArticle, format)
}

func writeArticleErrorResponse(w http.ResponseWriter, err error) {
	if !writeKnownArticleError(w, err) {
		http.Error(w, "Internal server error", http.StatusInternalServerError)
	}
}

func writeKnownArticleError(w http.ResponseWriter, err error) bool {
	if errors.Is(err, domain.ErrArticleNotFound) {
		http.Error(w, apperr.ArticleNotFoundErrorMessage, http.StatusNotFound)
		return true
	}
	if errors.Is(err, site.ErrSiteNotFound) {
		http.Error(w, apperr.SiteNotFoundErrorMessage, http.StatusNotFound)
		return true
	}
	if errors.Is(err, author.ErrAuthorNotFound) {
		http.Error(w, apperr.AuthorNotFoundErrorMessage, http.StatusNotFound)
		return true
	}
	if errors.Is(err, domain.ErrSlugTaken) {
		writeSlugTaken(w, err)
		return true
	}
	if errors.Is(err, domain.ErrInvalidSlug) {
		http.Error(w, apperr.InvalidSlugErrorMessage, http.StatusBadRequest)
		return true
	}
	if errors.Is(err, domain.ErrInvalidCanonicalURL) {
		http.Error(w, apperr.InvalidURLErrorMessage, http.StatusUnprocessableEntity)
		return true
	}
	if errors.Is(err, image.ErrImageNotFound) {
		http.Error(w, apperr.ArticleImageNotFoundErrorMessage, http.StatusBadRequest)
		return true
	}
	return false
}

func writeSlugTaken(w http.ResponseWriter, err error) {
	var conflict *domain.SlugTakenError
	if errors.As(err, &conflict) && conflict.Suggestion != "" {
		w.Header().Set(apperr.SlugSuggestionHeader, conflict.Suggestion)
	}
	http.Error(w, apperr.ArticleSlugTakenErrorMessage, http.StatusConflict)
}

func writeValidationError(w http.ResponseWriter, err error) {
	var failures playground.ValidationErrors
	if errors.As(err, &failures) {
		for _, failure := range failures {
			if failure.Tag() == validator.ArticleSlugTag {
				http.Error(w, apperr.InvalidSlugErrorMessage, http.StatusBadRequest)
				return
			}
		}
	}
	http.Error(w, err.Error(), http.StatusBadRequest)
}

func writeArticleJsonResponse(w http.ResponseWriter, status int, article domain.Article, format domain.BodyFormat) {
	articleJson, err := encodeArticle(article, format)
	if err != nil {
		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
		return
	}

	if status != http.StatusOK {
		w.WriteHeader(status)
	}
	if _, err := w.Write(articleJson); err != nil {
		log.Printf("Failed to write response: %v", err)
	}
}

func (h *Handler) setIsOnline(w http.ResponseWriter, r *http.Request, isOnline bool) {
	id, err := parseArticleId(r)
	if err != nil {
		http.Error(w, apperr.IdUint32ErrorMessage, http.StatusBadRequest)
		return
	}

	format, ok := parseBodyFormat(w, r)
	if !ok {
		return
	}

	updatedArticle, err := h.UpdateUseCase.UpdateIsOnline(r.Context(), id, isOnline, format)
	if err != nil {
		writeArticleErrorResponse(w, err)
		return
	}

	writeArticleJsonResponse(w, http.StatusOK, updatedArticle, format)
}

type optionalImageID struct {
	Set   bool
	Value *uint32 `validate:"omitempty,gte=1"`
}

func (o *optionalImageID) UnmarshalJSON(data []byte) error {
	o.Set = true
	if string(data) == "null" {
		o.Value = nil
		return nil
	}
	var value uint32
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	o.Value = &value
	return nil
}

func (o optionalImageID) toNullable() domain.Nullable[uint32] {
	return domain.Nullable[uint32]{Set: o.Set, Value: o.Value}
}

type UpdateArticleBody struct {
	Body              *string         `json:"body"`
	SiteID            *uint32         `json:"site_id" validate:"omitempty,gte=1"`
	AuthorIDs         *[]uint32       `json:"author_ids" validate:"omitempty,dive,gte=1"`
	Slug              *string         `json:"slug" validate:"omitempty,articleslug"`
	Excerpt           *string         `json:"excerpt" validate:"omitempty,max=300"`
	SEOTitle          *string         `json:"seo_title" validate:"omitempty,max=120"`
	SEODescription    *string         `json:"seo_description" validate:"omitempty,max=320"`
	CoverImageID      optionalImageID `json:"cover_image_id"`
	CoverImageAlt     *string         `json:"cover_image_alt" validate:"omitempty,max=200"`
	SocialTitle       *string         `json:"social_title" validate:"omitempty,max=120"`
	SocialDescription *string         `json:"social_description" validate:"omitempty,max=320"`
	SocialImageID     optionalImageID `json:"social_image_id"`
	CanonicalURL      *string         `json:"canonical_url" validate:"omitempty,max=2048"`
	Noindex           *bool           `json:"noindex"`
	SEODismissed      *[]string       `json:"seo_dismissed" validate:"omitempty,dive,oneof=title_long title_empty desc_short desc_long cover_alt cover_none slug_long no_au no_h body_alt short"`
}

var nonNullableArticleFields = []string{"body", "site_id", "author_ids", "slug", "excerpt", "seo_title", "seo_description", "cover_image_alt", "social_title", "social_description", "canonical_url", "noindex", "seo_dismissed"}

var nullableArticleFields = []string{"cover_image_id", "social_image_id"}

func hasDuplicates(ids []uint32) bool {
	seen := make(map[uint32]bool, len(ids))
	for _, id := range ids {
		if seen[id] {
			return true
		}
		seen[id] = true
	}
	return false
}

func countKnownFields(fields map[string]json.RawMessage, nonNullable []string) (int, bool) {
	known := 0
	for name, value := range fields {
		switch {
		case slices.Contains(nonNullable, name):
			if string(value) == "null" {
				return 0, false
			}
			known++
		case slices.Contains(nullableArticleFields, name):
			known++
		}
	}
	return known, true
}

func readUpdateArticleBody(r *http.Request) (UpdateArticleBody, bool) {
	raw, err := io.ReadAll(r.Body)
	if err != nil {
		return UpdateArticleBody{}, false
	}
	var fields map[string]json.RawMessage
	if err := json.Unmarshal(raw, &fields); err != nil {
		return UpdateArticleBody{}, false
	}
	known, ok := countKnownFields(fields, nonNullableArticleFields)
	if !ok || known == 0 {
		return UpdateArticleBody{}, false
	}
	var request UpdateArticleBody
	if err := json.Unmarshal(raw, &request); err != nil {
		return UpdateArticleBody{}, false
	}
	if request.AuthorIDs != nil && hasDuplicates(*request.AuthorIDs) {
		return UpdateArticleBody{}, false
	}
	return request, true
}

func (h *Handler) UpdateArticleBody(w http.ResponseWriter, r *http.Request) {
	id, err := parseArticleId(r)
	if err != nil {
		http.Error(w, apperr.IdUint32ErrorMessage, http.StatusBadRequest)
		return
	}

	format, ok := parseBodyFormat(w, r)
	if !ok {
		return
	}

	request, ok := readUpdateArticleBody(r)
	if !ok {
		http.Error(w, apperr.BodyErrorMessage, http.StatusBadRequest)
		return
	}

	if err := validator.Validate.Struct(request); err != nil {
		writeValidationError(w, err)
		return
	}

	updatedArticle, err := h.UpdateUseCase.Update(r.Context(), id, useCases.UpdateArticleCommand{
		Body:              request.Body,
		SiteID:            request.SiteID,
		AuthorIDs:         request.AuthorIDs,
		Slug:              request.Slug,
		Excerpt:           request.Excerpt,
		SEOTitle:          request.SEOTitle,
		SEODescription:    request.SEODescription,
		CoverImageID:      request.CoverImageID.toNullable(),
		CoverImageAlt:     request.CoverImageAlt,
		SocialTitle:       request.SocialTitle,
		SocialDescription: request.SocialDescription,
		SocialImageID:     request.SocialImageID.toNullable(),
		CanonicalURL:      request.CanonicalURL,
		Noindex:           request.Noindex,
		SEODismissed:      request.SEODismissed,
		Format:            format,
	})
	if err != nil {
		writeArticleErrorResponse(w, err)
		return
	}

	writeArticleJsonResponse(w, http.StatusOK, updatedArticle, format)
}

func (h *Handler) PublishArticle(w http.ResponseWriter, r *http.Request) {
	h.setIsOnline(w, r, true)
}

func (h *Handler) UnpublishArticle(w http.ResponseWriter, r *http.Request) {
	h.setIsOnline(w, r, false)
}

func (h *Handler) callerIsVerified(r *http.Request) bool {
	return isVerifiedCaller(r, h.GetUserUseCase)
}

func isVerifiedCaller(r *http.Request, getUser *useCases.GetUserUseCase) bool {
	userId, ok := claims.UserId(r)
	if !ok {
		return false
	}

	currentUser, err := getUser.GetUser(userId)
	if err != nil {
		return false
	}

	return currentUser.IsVerified
}

const (
	defaultListPage = 1
	defaultListSize = 25
)

type listQuery struct {
	Page   int     `validate:"gte=1"`
	Size   int     `validate:"oneof=5 25 50 100"`
	Q      string  `validate:"max=200"`
	Status string  `validate:"omitempty,oneof=online draft"`
	Site   *string `validate:"omitempty,min=1"`
	SEO    string  `validate:"omitempty,oneof=ready suggestions hidden"`
	Sort   string  `validate:"oneof=title:asc title:desc status:asc status:desc created_at:asc created_at:desc updated_at:asc updated_at:desc"`
}

const defaultListSort = "updated_at:desc"

func parseSort(value string) domain.Sort {
	field, direction, _ := strings.Cut(value, ":")
	return domain.Sort{Field: domain.SortField(field), Direction: domain.SortDirection(direction)}
}

type listResponse struct {
	Items  []listItemResponse `json:"items"`
	Total  int                `json:"total"`
	Page   int                `json:"page"`
	Size   int                `json:"size"`
	Counts domain.Counts      `json:"counts"`
}

func intQueryParam(values url.Values, name string, fallback int) (int, error) {
	if !values.Has(name) {
		return fallback, nil
	}
	return strconv.Atoi(values.Get(name))
}

func readListQuery(values url.Values) (listQuery, error) {
	page, err := intQueryParam(values, "page", defaultListPage)
	if err != nil {
		return listQuery{}, err
	}
	size, err := intQueryParam(values, "size", defaultListSize)
	if err != nil {
		return listQuery{}, err
	}
	status := values.Get("status")
	if values.Has("status") && status == "" {
		return listQuery{}, errors.New("empty status")
	}
	sortValue := defaultListSort
	if values.Has("sort") {
		sortValue = values.Get("sort")
	}
	var siteKey *string
	if values.Has("site") {
		key := values.Get("site")
		if key == "" {
			return listQuery{}, errors.New("empty site")
		}
		siteKey = &key
	}
	seoStatus := values.Get("seo")
	if values.Has("seo") && seoStatus == "" {
		return listQuery{}, errors.New("empty seo")
	}
	return listQuery{Page: page, Size: size, Q: values.Get("q"), Status: status, Sort: sortValue, Site: siteKey, SEO: seoStatus}, nil
}

func (h *Handler) ListArticles(w http.ResponseWriter, r *http.Request) {
	format, ok := parseBodyFormat(w, r)
	if !ok {
		return
	}

	query, err := readListQuery(r.URL.Query())
	if err != nil || validator.Validate.Struct(query) != nil {
		http.Error(w, apperr.BodyErrorMessage, http.StatusBadRequest)
		return
	}

	page, err := h.ListUseCase.ListArticlesPage(useCases.ListArticlesCommand{
		Format:   format,
		Verified: h.callerIsVerified(r),
		Page:     query.Page,
		Size:     query.Size,
		Q:        query.Q,
		Status:   query.Status,
		Sort:     parseSort(query.Sort),
		SiteKey:  query.Site,
		SEO:      query.SEO,
	})
	if err != nil {
		http.Error(w, "Failed to retrieve articles", http.StatusInternalServerError)
		return
	}

	responses := make([]listItemResponse, 0, len(page.Items))
	for _, article := range page.Items {
		response, err := toListItemResponse(article, page.SEO[article.ID], format)
		if err != nil {
			http.Error(w, "Failed to encode response", http.StatusInternalServerError)
			return
		}
		responses = append(responses, response)
	}

	articlesJson, err := json.Marshal(listResponse{Items: responses, Total: page.Total, Page: page.Page, Size: page.Size, Counts: page.Counts})
	if err != nil {
		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
		return
	}

	if _, err := w.Write(articlesJson); err != nil {
		log.Printf("Failed to write response: %v", err)
	}
}

func (h *Handler) DeleteArticle(w http.ResponseWriter, r *http.Request) {
	id, err := parseArticleId(r)
	if err != nil {
		http.Error(w, apperr.IdUint32ErrorMessage, http.StatusBadRequest)
		return
	}

	if err := h.DeleteUseCase.DeleteArticle(r.Context(), id); err != nil {
		if errors.Is(err, domain.ErrArticleNotFound) {
			http.Error(w, apperr.ArticleNotFoundErrorMessage, http.StatusNotFound)
			return
		}
		http.Error(w, "Failed to delete article", http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusNoContent)
}