package endpoints

import (
	"net/http"

	"rag/file-system/internal/api/handlers"
	"rag/file-system/internal/api/requests"
	"rag/file-system/internal/api/validators"
	"rag/file-system/internal/domain/model"
	"rag/file-system/internal/infrastructure/mediator"
	"rag/file-system/internal/middleware"

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

type FolderEndpoint struct {
	Mediator        *mediator.Mediator
	FolderValidator *validators.FolderValidator
}

func NewFolderEndpoint(m *mediator.Mediator, fv *validators.FolderValidator) *FolderEndpoint {
	return &FolderEndpoint{Mediator: m, FolderValidator: fv}
}

func (e *FolderEndpoint) CreateFolder(c *gin.Context) {
	var req requests.CreateFolderRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	if err := e.FolderValidator.ValidateCreate(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	ownerID := c.GetString(middleware.ContextKeyUserID)
	cmd := handlers.CreateFolderCommand{
		Name:     req.Name,
		ParentID: req.ParentID,
		OwnerID:  ownerID,
	}

	result, err := mediator.Send[handlers.CreateFolderCommand, *model.Folder](e.Mediator, c.Request.Context(), cmd)
	if err != nil {
		handleError(c, err)
		return
	}
	c.JSON(http.StatusOK, gin.H{"data": result})
}

func (e *FolderEndpoint) GetFolder(c *gin.Context) {
	folderID := c.Param("id")
	ownerID := c.GetString(middleware.ContextKeyUserID)

	query := handlers.GetFolderQuery{FolderID: folderID, OwnerID: ownerID}
	result, err := mediator.Send[handlers.GetFolderQuery, *model.FolderWithChildren](e.Mediator, c.Request.Context(), query)
	if err != nil {
		handleError(c, err)
		return
	}
	c.JSON(http.StatusOK, gin.H{"data": result})
}

func (e *FolderEndpoint) GetFolderTree(c *gin.Context) {
	ownerID := c.GetString(middleware.ContextKeyUserID)

	query := handlers.GetFolderTreeQuery{OwnerID: ownerID}
	result, err := mediator.Send[handlers.GetFolderTreeQuery, []model.Folder](e.Mediator, c.Request.Context(), query)
	if err != nil {
		handleError(c, err)
		return
	}
	c.JSON(http.StatusOK, gin.H{"data": result})
}

func (e *FolderEndpoint) RenameFolder(c *gin.Context) {
	folderID := c.Param("id")
	var req requests.RenameFolderRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	if err := e.FolderValidator.ValidateRename(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	ownerID := c.GetString(middleware.ContextKeyUserID)
	cmd := handlers.RenameFolderCommand{FolderID: folderID, Name: req.Name, OwnerID: ownerID}

	result, err := mediator.Send[handlers.RenameFolderCommand, *model.Folder](e.Mediator, c.Request.Context(), cmd)
	if err != nil {
		handleError(c, err)
		return
	}
	c.JSON(http.StatusOK, gin.H{"data": result})
}

func (e *FolderEndpoint) DeleteFolder(c *gin.Context) {
	folderID := c.Param("id")
	ownerID := c.GetString(middleware.ContextKeyUserID)

	cmd := handlers.DeleteFolderCommand{FolderID: folderID, OwnerID: ownerID}
	result, err := mediator.Send[handlers.DeleteFolderCommand, string](e.Mediator, c.Request.Context(), cmd)
	if err != nil {
		handleError(c, err)
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": result})
}

func (e *FolderEndpoint) UploadToFolder(c *gin.Context) {
	folderID := c.Param("folderId")
	ownerID := c.GetString(middleware.ContextKeyUserID)

	file, header, err := c.Request.FormFile("file")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "请选择文件"})
		return
	}
	defer file.Close()

	s3Bucket := c.DefaultPostForm("bucket", "default")

	cmd := handlers.UploadToFolderCommand{
		FolderID:    folderID,
		FileName:    header.Filename,
		Data:        file,
		S3Bucket:    s3Bucket,
		OwnerID:     ownerID,
		Size:        header.Size,
		ContentType: header.Header.Get("Content-Type"),
	}

	result, err := mediator.Send[handlers.UploadToFolderCommand, *model.FileMeta](e.Mediator, c.Request.Context(), cmd)
	if err != nil {
		handleError(c, err)
		return
	}
	c.JSON(http.StatusOK, gin.H{"data": result})
}

func (e *FolderEndpoint) MoveFile(c *gin.Context) {
	fileID := c.Param("id")
	var req requests.MoveFileRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	ownerID := c.GetString(middleware.ContextKeyUserID)
	cmd := handlers.MoveFileCommand{
		FileID:         fileID,
		TargetFolderID: req.TargetFolderID,
		OwnerID:        ownerID,
	}

	result, err := mediator.Send[handlers.MoveFileCommand, string](e.Mediator, c.Request.Context(), cmd)
	if err != nil {
		handleError(c, err)
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": result})
}