package patchmanager

import (
	"io/fs"
	"os"
	"testing"

	"github.com/go-logr/logr"

	"edge-infra.dev/pkg/lib/logging"
	"edge-infra.dev/pkg/sds/patching/common"
	"edge-infra.dev/pkg/sds/patching/test"
)

// If both vars are zero-value, returns true.
func TestContains(t *testing.T) {
	scenarios := []struct {
		inputNodeList []string
		inputNodeName string
		expect        bool
	}{
		{inputNodeList: []string{"s1-master-1", "s1-worker-2", "s1-worker-3"}, inputNodeName: "s1-master-1", expect: true},
		{inputNodeList: []string{"s1-master-1", "s1-worker-2", "s1-worker-3"}, inputNodeName: "s1-worker-9", expect: false},
	}

	for _, s := range scenarios {
		got := Contains(s.inputNodeList, s.inputNodeName)
		if got != s.expect {
			t.Errorf("Unexpected result with the node list %v and node name %s. Wanted: %t; Got: %t\n", s.inputNodeList, s.inputNodeName, s.expect, got)
		}
	}
}

func TestGeneratePatchingEnv(t *testing.T) {
	scenarios := []struct {
		currentVer, targetVer string
		cfg                   common.Config
		expect                string
	}{
		{
			currentVer: "v1.10.2",
			targetVer:  "v1.11.0",
			cfg:        test.NewConfig(t),
			expect:     "CURRENT='v1.10.2'\nTARGET='v1.11.0'\n",
		},
	}

	for _, s := range scenarios {
		if err := test.CreateFileTree(s.cfg); err != nil {
			t.Errorf("unable to create file tree: %s", err)
		}

		if err := generatePatchingEnv(s.currentVer, s.targetVer, s.cfg.EnvFilePath); err != nil {
			t.Errorf("%s", err)
		}

		got, err := os.ReadFile(s.cfg.EnvFilePath)
		if err != nil {
			t.Errorf("error reading patching.env file: %s\n", err)
		}

		if string(got) != s.expect {
			t.Errorf("error generating patching.env file, invalid file contents: %s", err)
		}
	}
}

func TestRequestReboot(t *testing.T) {
	scenarios := []struct {
		autoreboot bool
		log        logr.Logger
		cfg        common.Config
		expect     struct {
			name string
			mode fs.FileMode
		}
	}{
		{
			autoreboot: true,
			log:        logging.NewLogger().Logger,
			cfg:        test.NewConfig(t),
			expect: struct {
				name string
				mode fs.FileMode
			}{
				name: "reboot-required",
				mode: os.FileMode(0755),
			},
		},
		{
			autoreboot: false,
			log:        logging.NewLogger().Logger,
			cfg:        test.NewConfig(t),
			expect: struct {
				name string
				mode fs.FileMode
			}{
				name: "reboot-required",
				mode: os.FileMode(0755),
			},
		},
	}

	for _, s := range scenarios {
		if err := requestReboot(s.autoreboot, s.log, s.cfg); err != nil {
			t.Errorf("%s", err)
		}

		if !s.autoreboot {
			continue
		}

		got, err := os.Stat(s.cfg.RebootPath)
		if err != nil {
			t.Errorf("error reading patching.env file: %s\n", err)
		}

		if got.Name() != s.expect.name {
			t.Errorf("error generating reboot-required file, invalid file name: %s", err)
		}

		if got.Mode() != s.expect.mode {
			t.Errorf("error generating reboot-required file, invalid file permissions: %s", err)
		}
	}
}