package http

import (
	"net/http"

	"github.com/gin-gonic/gin"
	"gitlink.org.cn/cloudream/common/pkgs/logger"
	"gitlink.org.cn/cloudream/jcs-pub/client/internal/http/types"
	cliapi "gitlink.org.cn/cloudream/jcs-pub/client/sdk/api/v1"
	"gitlink.org.cn/cloudream/jcs-pub/common/ecode"
	jcstypes "gitlink.org.cn/cloudream/jcs-pub/common/types"
)

type SpaceSyncerService struct {
	*Server
}

func (s *Server) SpaceSyncer() *SpaceSyncerService {
	return &SpaceSyncerService{s}
}

func (s *SpaceSyncerService) CreateTask(ctx *gin.Context) {
	log := logger.WithField("HTTP", "SpaceSyncer.CreateTask")

	req, err := types.ShouldBindJSONEx[cliapi.SpaceSyncerCreateTask](ctx)
	if err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	if len(req.DestPathes) != len(req.DestUserSpaceIDs) {
		log.Warnf("destPathes and destUserSpaceIDs should have the same length")
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "destPathes and destUserSpaceIDs should have the same length"))
		return
	}

	if len(req.DestPathes) == 0 {
		log.Warnf("must have at least one dest")
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "must have at least one dest"))
		return
	}

	dests := make([]jcstypes.SpaceSyncDest, 0, len(req.DestUserSpaceIDs))
	for _, id := range req.DestUserSpaceIDs {
		dests = append(dests, jcstypes.SpaceSyncDest{
			DestUserSpaceID: jcstypes.UserSpaceID(id),
			DestPath:        jcstypes.PathFromJcsPathString(req.DestPathes[0]),
		})
	}

	info, err := s.svc.SpaceSyncer.CreateTask(jcstypes.SpaceSyncTask{
		Trigger:        req.Trigger,
		Mode:           req.Mode,
		Filters:        req.Filters,
		Options:        req.Options,
		SrcUserSpaceID: req.SrcUserSpaceID,
		SrcPath:        jcstypes.PathFromJcsPathString(req.SrcPath),
		Dests:          dests,
	})
	if err != nil {
		log.Warnf("start task: %s", err.Error())
		ctx.JSON(http.StatusInternalServerError, types.Failed(ecode.OperationFailed, "start task: %v", err))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.SpaceSyncerCreateTaskResp{
		Task: info.Task,
	}))
}

func (s *SpaceSyncerService) CancelTask(ctx *gin.Context) {
	log := logger.WithField("HTTP", "SpaceSyncer.CancelTask")

	var req cliapi.SpaceSyncerCancelTask
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	s.svc.SpaceSyncer.CancelTask(req.TaskID)
	ctx.JSON(http.StatusOK, types.OK(cliapi.SpaceSyncerCancelTaskResp{}))
}

func (s *SpaceSyncerService) GetTask(ctx *gin.Context) {
	log := logger.WithField("HTTP", "SpaceSyncer.GetTask")

	var req cliapi.SpaceSyncerGetTask
	if err := ctx.ShouldBindQuery(&req); err != nil {
		log.Warnf("binding query: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	task := s.svc.SpaceSyncer.GetTask(req.TaskID)
	if task == nil {
		ctx.JSON(http.StatusOK, types.Failed(ecode.DataNotFound, "task not found"))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.SpaceSyncerGetTaskResp{Task: *task}))
}