// SPDX-FileCopyrightText: 2025 Romain Maneschi <romain@gitroot.dev>
//
// SPDX-License-Identifier: EUPL-1.2

package plugin

import (
	"embed"
	"testing"

	"github.com/go-git/go-git/v6/plumbing"
	"gitroot.dev/libs/golang/glob"
	pluginLib "gitroot.dev/libs/golang/plugin/model"
)

//go:embed *
var fakeFs embed.FS

type dataCheckBranchTest struct {
	name       string
	pr         PluginRun
	branch     string
	shouldBeOk bool
}

func TestCheckBranch(t *testing.T) {
	data := []dataCheckBranchTest{
		{name: "empty", pr: buildPluginRun([]string{}, buildPluginWriteRight("")), branch: "main", shouldBeOk: false},
		{name: "main ok", pr: buildPluginRun([]string{"main"}, buildPluginWriteRight("")), branch: "main", shouldBeOk: true},
		{name: "main2 ko", pr: buildPluginRun([]string{"main"}, buildPluginWriteRight("")), branch: "main2", shouldBeOk: false},
		{name: "multiple ok", pr: buildPluginRun([]string{"*"}, buildPluginWriteRight("")), branch: "main", shouldBeOk: true},
		{name: "multiple ko", pr: buildPluginRun([]string{"*", "!main"}, buildPluginWriteRight("")), branch: "main", shouldBeOk: false},
	}

	for _, d := range data {
		pr := d.pr
		ok := checkBranch(pr, plumbing.NewBranchReferenceName(d.branch))
		if ok != d.shouldBeOk {
			t.Fatalf("%s fail with %t should be %t", d.name, ok, d.shouldBeOk)
		}
	}
}

type dataCheckRightWriteTest struct {
	name       string
	pr         PluginRun
	path       string
	shouldBeOk bool
}

func TestCheckRightWrite(t *testing.T) {
	data := []dataCheckRightWriteTest{
		{name: "empty", pr: buildPluginRun([]string{}, buildPluginWriteRight("")), path: "main", shouldBeOk: false},
		{name: "add notExisting", pr: buildPluginRun([]string{}, buildPluginWriteRight("notExisting", pluginLib.PluginWriteRightCanAdd)), path: "notExisting", shouldBeOk: true},
		{name: "add existing with right", pr: buildPluginRun([]string{}, buildPluginWriteRight("runtime.go", pluginLib.PluginWriteRightCanAdd)), path: "runtime.go", shouldBeOk: false},
		{name: "add notExisting without right", pr: buildPluginRun([]string{}, buildPluginWriteRight("notExisting", pluginLib.PluginWriteRightCanAdd)), path: "runtime.go", shouldBeOk: false},
		{name: "mod notExisting with right", pr: buildPluginRun([]string{}, buildPluginWriteRight("notExisting", pluginLib.PluginWriteRightCanMod)), path: "notExisting", shouldBeOk: false},
		{name: "mod notExisting without right", pr: buildPluginRun([]string{}, buildPluginWriteRight("notExisting", pluginLib.PluginWriteRightCanDel)), path: "notExisting", shouldBeOk: false},
		{name: "mod existing with right", pr: buildPluginRun([]string{}, buildPluginWriteRight("runtime.go", pluginLib.PluginWriteRightCanMod)), path: "runtime.go", shouldBeOk: true},
	}

	for _, d := range data {
		pr := d.pr
		ok, err := checkWrite(pr.write.git, fakeFs, d.path)
		if ok != d.shouldBeOk {
			t.Fatalf("%s fail with %t and %s should be %t", d.name, ok, err, d.shouldBeOk)
		}
	}
}

func buildPluginRun(branches []string, rights []PluginWriteRight) PluginRun {
	return PluginRun{
		PluginRun: pluginLib.PluginRun{
			Path:   "**/*",
			Branch: branches,
			When:   pluginLib.PluginRunWhenAll,
			Write: pluginLib.PluginWrite{
				Git: []pluginLib.PluginWriteRight{},
				Web: []pluginLib.PluginWriteRight{},
			},
			Configuration: nil,
		},
		write: PluginWrite{
			git: rights,
			web: []PluginWriteRight{},
		},
	}
}

func buildPluginWriteRight(path string, can ...pluginLib.PluginWriteRightCan) []PluginWriteRight {
	if path == "" {
		return []PluginWriteRight{}
	}
	g, _ := glob.NewGlob(path)
	return []PluginWriteRight{
		{glob: g, PluginWriteRight: pluginLib.PluginWriteRight{Path: path, Can: can}},
	}
}