package runner

import (
	"fmt"
	"git.0x7f.app/WOJ/woj-server/internal/e"
	"git.0x7f.app/WOJ/woj-server/pkg/file"
	"go.uber.org/zap"
	"os"
	"path"
	"path/filepath"
)

var (
	Prefix = "./resource/runner"

	ProblemDir    = "./problem/"
	UserDir       = "./user/"
	TmpDir        = "./tmp/"
	NSJailFile    = "./framework/scripts/nsjail"
	RootfsFullDir = "./framework/rootfs/full"
	RootfsRunDir  = "./framework/rootfs/run"
)

type JudgeMetaRun struct {
	Version uint   // problem version id
	User    string // user id
	Lang    string // language
}

type JudgeMetaConfig struct {
	All  *Config
	Lang *ConfigLanguage
}

type JudgeMeta struct {
	Run JudgeMetaRun
	Cfg JudgeMetaConfig
}

func init() {
	wd, err := os.Getwd()
	if err != nil {
		panic(err)
	}

	Prefix = path.Join(wd, Prefix)
	ProblemDir = path.Join(Prefix, ProblemDir)
	UserDir = path.Join(Prefix, UserDir)
	TmpDir = path.Join(Prefix, TmpDir)
	NSJailFile = path.Join(Prefix, NSJailFile)
	RootfsFullDir = path.Join(Prefix, RootfsFullDir)
	RootfsRunDir = path.Join(Prefix, RootfsRunDir)
}

func (s *service) ProblemExists(meta *JudgeMeta) bool {
	problemPath := filepath.Join(ProblemDir, fmt.Sprintf("%d", meta.Run.Version))
	return file.Exist(problemPath)
}

func (s *service) ValidatePath(meta *JudgeMeta) (*JudgeStatus, e.Status) {
	gen := func(status e.Status) (*JudgeStatus, e.Status) {
		return &JudgeStatus{
			Message:        fmt.Sprintf("System Error: Problem/User Files Not Found (%d:%s)", status, status.String()),
			CompileMessage: "",
			Tasks:          []TaskStatus{{Verdict: VerdictSystemError, Message: "System Error"}},
		}, status
	}

	if !s.ProblemExists(meta) {
		s.log.Error("problem not exists", zap.Uint("version", meta.Run.Version))
		return gen(e.RunnerProblemNotExist)
	}

	userPath := filepath.Join(UserDir, meta.Run.User, fmt.Sprintf("%s.%s", meta.Run.User, meta.Run.Lang))
	if !file.Exist(userPath) {
		s.log.Error("user program not exists", zap.String("user", meta.Run.User), zap.String("lang", meta.Run.Lang))
		return gen(e.RunnerUserNotExist)
	}

	return nil, e.Success
}

func (s *service) GetConfig(meta *JudgeMeta, skipCheck bool) e.Status {
	config, err := s.ParseConfig(meta, skipCheck)
	if err != nil {
		return e.RunnerProblemParseFailed
	}

	lang, ok := config.FilterLanguage(meta.Run.Lang)
	if !ok {
		return e.RunnerLanguageNotSupported
	}

	meta.Cfg = JudgeMetaConfig{
		All:  config,
		Lang: lang,
	}
	return e.Success
}