package task

import (
	"code.gitea.io/gitea/models"
	"code.gitea.io/gitea/modules/log"
	"code.gitea.io/gitea/modules/util"
	"code.gitea.io/gitea/services/reward"
	"code.gitea.io/gitea/services/reward/limiter"
	"fmt"
)

func Accomplish(action models.Action) {
	switch action.OpType {
	case models.ActionCreateRepo,
		models.ActionCreateImage:
		if action.Repo.IsPrivate {
			return
		}
	case models.ActionCreateDebugGPUTask,
		models.ActionCreateDebugNPUTask,
		models.ActionCreateTrainTask,
		models.ActionCreateInferenceTask,
		models.ActionCreateBenchMarkTask,
		models.ActionCreateGPUTrainTask:
		action.OpType = models.ActionCreateCloudbrainTask
	}
	go accomplish(action)
}

func accomplish(action models.Action) error {
	defer func() {
		if err := recover(); err != nil {
			combinedErr := fmt.Errorf("%s\n%s", err, log.Stack(2))
			log.Error("PANIC:%v", combinedErr)
		}
	}()
	userId := action.ActUserID
	taskType := fmt.Sprint(action.OpType)

	//get task config
	config, err := GetTaskConfig(taskType)
	if err != nil {
		log.Error("GetTaskConfig error,%v", err)
		return err
	}
	if config == nil {
		log.Info("task config not exist,userId=%d taskType=%s", userId, taskType)
		return nil
	}

	//is limited?
	if isLimited(userId, config, limiter.JustReject) {
		log.Info("task accomplish maximum times are reached,userId=%d taskType=%s", userId, taskType)
		return nil
	}

	//add log
	logId := util.UUID()
	_, err = models.InsertTaskAccomplishLog(&models.TaskAccomplishLog{
		LogId:    logId,
		ConfigId: config.ID,
		TaskCode: config.TaskCode,
		UserId:   userId,
		ActionId: action.ID,
	})
	if err != nil {
		return err
	}

	//reward
	reward.Operate(&models.RewardOperateContext{
		SourceType: models.SourceTypeAccomplishTask,
		SourceId:   logId,
		Tittle:     config.Tittle,
		Reward: models.Reward{
			Amount: config.AwardAmount,
			Type:   models.GetRewardTypeInstance(config.AwardType),
		},
		TargetUserId: userId,
		RequestId:    logId,
		OperateType:  models.OperateTypeIncrease,
		RejectPolicy: limiter.FillUp,
	})

	return nil
}

func isLimited(userId int64, config *models.TaskConfig, rejectPolicy limiter.LimiterRejectPolicy) bool {
	if _, err := limiter.CheckLimit(config.TaskCode, models.LimitTypeTask, userId, 1, rejectPolicy); err != nil {
		return true
	}
	return false

}