internal

var EmptyRepoRules = []labels.Rule{
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.EmptyRepo
		_, err = c.FindFileMatching(func(path string) bool {
			if path == "." || strings.TrimSpace(strings.ToLower(path)) == "readme.md" {
				return false
			}

			return true
		}, "*")

		if errors.Is(err, codebase.NotFoundError) {
			label.Valid = true
			return label, nil
		}
		return label, err
	},
}

var GithubActionRules = []labels.Rule{
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.CICDGithubActions
		configPath, err := c.FindFile(".github/workflows/*.yml", ".github/workflows/*.yaml")
		label.Valid = configPath != ""
		label.BasePath = path.Dir(configPath)
		return label, err
	},
}

var GitlabWorkflowRules = []labels.Rule{
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.CICDGitlabWorkflow
		configPath, err := c.FindFile(".gitlab-ci.yml")
		label.Valid = configPath != ""
		label.BasePath = path.Dir(configPath)
		return label, err
	},
}

var GoRules = []labels.Rule{
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.DepsGo
		goModPath, err := c.FindFile("go.mod")
		label.Valid = goModPath != ""
		label.BasePath = path.Dir(goModPath)
		lockFilePath, _ := c.FindFile("go.sum")
		label.LabelData.HasLockFile = lockFilePath != ""
		return label, err
	},
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.ArtifactGoExecutable
		if !ls[labels.DepsGo].Valid {
			return label, err
		}

		label.Valid = containsMainGoFiles(c)
		return label, err
	},
}

var JavaRules = []labels.Rule{
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.DepsJava
		pomXml, err := c.FindFile("pom.xml", "gradlew")
		label.Valid = pomXml != ""
		label.BasePath = path.Dir(pomXml)
		return label, err
	},
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.ToolGradle
		gradlew, err := c.FindFile("gradlew")
		label.Valid = gradlew != "" && path.Dir(gradlew) == ls[labels.DepsJava].BasePath
		return label, err
	},
}

var JenkinsRules = []labels.Rule{
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.CICDJenkins
		configPath, err := c.FindFile("Jenkinsfile")
		label.Valid = configPath != ""
		label.BasePath = path.Dir(configPath)
		return label, err
	},
}

var NodeRules = []labels.Rule{
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.DepsNode
		packagePath := findPackageJSON(c)
		label.Valid = packagePath != ""
		if !label.Valid {
			return label, err
		}
		err = readPackageJSON(c, packagePath, &label)

		lockFilesPath, _ := c.FindFile(lockFiles...)
		label.LabelData.HasLockFile = lockFilesPath != ""

		return label, err
	},
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.PackageManagerYarn
		yarnLock, _ := c.FindFile("yarn.lock")

		if yarnLock == "" {
			return label, err
		}

		label.Valid = true
		label.Version = "classic"

		yarnrc, _ := c.FindFile(".yarnrc.yml", ".yarnrc.yaml")
		if yarnrc != "" {
			label.Version = "berry"
		}

		return label, err
	},
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.TestJest
		label.Valid = hasDependency(ls, "jest")
		return label, err
	},
}

var PhpRules = []labels.Rule{
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.DepsPhp
		label.Dependencies = make(map[string]string)

		composerPath, err := c.FindFile("composer.json")
		if err != nil && !errors.Is(err, codebase.NotFoundError) {
			return label, err

		}
		if composerPath != "" {
			label.Valid = true
			label.BasePath = path.Dir(composerPath)
		}

		err = readComposerFile(c, composerPath, &label)
		return label, err
	},
}

var PythonRules = []labels.Rule{
	func(c codebase.Codebase, ls labels.LabelSet) (labels.Label, error) {
		label := labels.Label{
			Key: labels.DepsPython,
		}
		filePath, _ := c.FindFile(possiblePythonFiles...)
		label.Valid = filePath != ""
		label.BasePath = path.Dir(filePath)

		pythonVersion := getPythonVersion(c)
		if pythonVersion != "" {
			label.Dependencies = map[string]string{
				"python": pythonVersion,
			}
		}

		return label, nil
	},
	func(c codebase.Codebase, ls labels.LabelSet) (labels.Label, error) {
		label := labels.Label{
			Key: labels.PackageManagerPipenv,
		}
		pipfile, _ := c.FindFile(pipenvFiles...)
		label.Valid = pipfile != ""
		label.BasePath = path.Dir(pipfile)

		pyprojectPath, _ := c.FindFile("pyproject.toml")
		if pyprojectPath != "" && fileContainsString(c, pyprojectPath, "pipenv") {
			label.Valid = true
			label.BasePath = path.Dir(pyprojectPath)
		}

		return label, nil
	},
	func(c codebase.Codebase, ls labels.LabelSet) (labels.Label, error) {
		label := labels.Label{
			Key: labels.PackageManagerPoetry,
		}
		poetryLock, _ := c.FindFile(poetryFiles...)
		label.Valid = poetryLock != ""
		label.BasePath = path.Dir(poetryLock)

		pyprojectPath, _ := c.FindFile("pyproject.toml")
		if pyprojectPath != "" && fileContainsString(c, pyprojectPath, "poetry") {
			label.Valid = true
			label.BasePath = path.Dir(pyprojectPath)
		}

		return label, nil
	},
	func(c codebase.Codebase, ls labels.LabelSet) (labels.Label, error) {
		label := labels.Label{
			Key: labels.FileManagePy,
		}
		managePyPath, _ := c.FindFile("manage.py")
		label.Valid = managePyPath != ""
		label.BasePath = path.Dir(managePyPath)
		return label, nil
	},
	func(c codebase.Codebase, ls labels.LabelSet) (labels.Label, error) {
		label := labels.Label{
			Key: labels.FileSetupPy,
		}
		setupPath, _ := c.FindFile("setup.py")
		label.Valid = setupPath != ""
		label.BasePath = path.Dir(setupPath)
		return label, nil
	},
	func(c codebase.Codebase, ls labels.LabelSet) (labels.Label, error) {
		label := labels.Label{Key: labels.TestTox}
		toxPath, _ := c.FindFile("tox.ini")
		label.Valid = toxPath != ""
		label.BasePath = path.Dir(toxPath)
		return label, nil
	},
}

var RubyRules = []labels.Rule{
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.DepsRuby
		label.Dependencies = make(map[string]string)

		gemfilePath, err := c.FindFile("Gemfile")
		if err != nil && !errors.Is(err, codebase.NotFoundError) {
			return label, err
		}
		if gemfilePath != "" {
			label.Valid = true
			label.BasePath = path.Dir(gemfilePath)
			err = readDepsFile(c, label.Dependencies, gemfilePath)
			if err != nil {
				return label, err
			}
			label.HasLockFile = hasPath(c, path.Join(path.Dir(gemfilePath), "Gemfile.lock"))
		}
		return label, nil
	},
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.PackageManagerGemspec
		label.Dependencies = make(map[string]string)

		gemspecPath, err := c.FindFile("*.gemspec")
		if err != nil && !errors.Is(err, codebase.NotFoundError) {
			return label, err
		}

		if gemspecPath != "" {
			label.Valid = true
			label.BasePath = path.Dir(gemspecPath)
			err = readDepsFile(c, label.Dependencies, gemspecPath)
			if err != nil {
				return label, err
			}
		}
		return label, nil
	},
}

var RustRules = []labels.Rule{
	func(c codebase.Codebase, ls labels.LabelSet) (label labels.Label, err error) {
		label.Key = labels.DepsRust
		cargoTomlFile, err := c.FindFile("Cargo.toml", "cargo.toml")
		label.Valid = cargoTomlFile != ""
		label.BasePath = path.Dir(cargoTomlFile)
		return label, err
	},
}