package image

import (
	"RenewCMS/api/pkg/apperr"
	domainArticle "RenewCMS/internal/domain/article"
	domainImage "RenewCMS/internal/domain/image"
	"RenewCMS/internal/infrastructure/useCases"
	"encoding/json"
	"errors"
	"net/http"
	"strconv"

	"github.com/go-chi/chi/v5"
)

type Handler struct {
	CreateUseCase *useCases.CreateImageUseCase
	GetUseCase    *useCases.GetArticleUseCase
	UpdateUseCase *useCases.UpdateArticleUseCase
}

func NewHandler(create *useCases.CreateImageUseCase, get *useCases.GetArticleUseCase, update *useCases.UpdateArticleUseCase) *Handler {
	return &Handler{
		CreateUseCase: create,
		GetUseCase:    get,
		UpdateUseCase: update,
	}
}

func writeInternalServerError(w http.ResponseWriter) {
	http.Error(w, "Internal server error", http.StatusInternalServerError)
}

func writeArticleError(w http.ResponseWriter, err error) {
	if errors.Is(err, domainArticle.ErrArticleNotFound) {
		http.Error(w, apperr.ArticleNotFoundErrorMessage, http.StatusNotFound)
		return
	}
	writeInternalServerError(w)
}

func (h *Handler) PostImage(w http.ResponseWriter, r *http.Request) {
	articleId, err := strconv.ParseUint(chi.URLParam(r, "id"), 10, 32)
	if err != nil {
		http.Error(w, apperr.IdUint32ErrorMessage, http.StatusBadRequest)
		return
	}

	if _, err := h.GetUseCase.GetArticle(uint32(articleId)); err != nil {
		writeArticleError(w, err)
		return
	}

	file, fileHeader, err := r.FormFile("file")
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
	defer file.Close()

	newImage, err := h.CreateUseCase.CreateImage(domainImage.ImageInput{
		Content:     file,
		Filename:    fileHeader.Filename,
		Size:        fileHeader.Size,
		ContentType: fileHeader.Header.Get("Content-Type"),
	})
	if err != nil {
		if errors.Is(err, domainImage.ErrImageTypeNotAllowed) || errors.Is(err, domainImage.ErrImageTooLarge) {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
		writeInternalServerError(w)
		return
	}

	if err := h.UpdateUseCase.AddImage(uint32(articleId), newImage.ID); err != nil {
		writeArticleError(w, err)
		return
	}

	responseJson, err := json.Marshal(map[string]any{"location": newImage.Path})
	if err != nil {
		writeInternalServerError(w)
		return
	}

	w.WriteHeader(http.StatusCreated)
	_, _ = w.Write(responseJson)
}