//go:build linux

package installer

import (
	"os/exec"
	"testing"

	"gitgud.io/mike/mpv-manager/pkg/constants"
	"gitgud.io/mike/mpv-manager/pkg/platform"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// newLinuxTestCommandRunner wraps the shared newTestCommandRunner helper
// (verify_test.go), discarding the output channel.
func newLinuxTestCommandRunner() *CommandRunner {
	cr, _ := newTestCommandRunner()
	return cr
}

// TestInstallMPVViaPackageWithOutput_UnsupportedFamily verifies that an
// unsupported distro family returns a descriptive error instead of panicking
// on a nil command slice (regression: openSUSE/unknown family index panic).
func TestInstallMPVViaPackageWithOutput_UnsupportedFamily(t *testing.T) {
	li := &LinuxInstaller{Platform: &platform.Platform{DistroFamily: "unknown-family"}}

	err := li.InstallMPVViaPackageWithOutput(newLinuxTestCommandRunner(), constants.UITypeNone, false)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "unknown-family")

	err = li.InstallMPVViaPackageWithOutput(newLinuxTestCommandRunner(), constants.UITypeNone, true)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "unknown-family")
}

func TestInstallCelluloidViaPackageWithOutput_UnsupportedFamily(t *testing.T) {
	li := &LinuxInstaller{Platform: &platform.Platform{DistroFamily: "unknown-family"}}

	err := li.InstallCelluloidViaPackageWithOutput(newLinuxTestCommandRunner(), false)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "unknown-family")

	err = li.InstallCelluloidViaPackageWithOutput(newLinuxTestCommandRunner(), true)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "unknown-family")
}

func TestUninstallViaPackageWithOutput_UnsupportedFamily(t *testing.T) {
	li := &LinuxInstaller{Platform: &platform.Platform{DistroFamily: "unknown-family"}}

	err := li.UninstallViaPackageWithOutput(newLinuxTestCommandRunner(), "mpv")
	require.Error(t, err)
	assert.Contains(t, err.Error(), "unknown-family")
}

func TestEnsureGSettingsInstalled_UnsupportedFamily(t *testing.T) {
	if _, err := exec.LookPath(constants.CommandGsettings); err == nil {
		t.Skip("gsettings present on host; unsupported-family path not reachable")
	}

	li := &LinuxInstaller{Platform: &platform.Platform{DistroFamily: "unknown-family"}}

	err := li.EnsureGSettingsInstalled(newLinuxTestCommandRunner())
	require.Error(t, err)
	assert.Contains(t, err.Error(), "unknown-family")
}

// TestGetAvailableMethods_UnsupportedFamily verifies package-manager methods
// are hidden on unsupported families while Flatpak alternatives remain.
func TestGetAvailableMethods_UnsupportedFamily(t *testing.T) {
	li := &LinuxInstaller{Platform: &platform.Platform{DistroFamily: "unknown-family"}}

	methods := li.GetAvailableMethods(false)
	require.NotEmpty(t, methods)

	var flatpakFound bool
	for _, m := range methods {
		assert.NotEqual(t, constants.MethodMPVPackage, m.ID)
		assert.NotEqual(t, constants.MethodCelluloidPackage, m.ID)
		if m.ID == constants.MethodMPVFlatpak || m.ID == constants.MethodCelluloidFlatpak {
			flatpakFound = true
		}
	}
	assert.True(t, flatpakFound, "flatpak alternatives should still be offered")
}

// TestGetAvailableMethods_SupportedFamilies verifies package-manager methods
// are offered for families with a PackageManagerConfigs entry.
func TestGetAvailableMethods_SupportedFamilies(t *testing.T) {
	for _, family := range []string{
		constants.PMFamilyDebian,
		constants.PMFamilyRHEL,
		constants.PMFamilyArch,
		constants.PMFamilySUSE,
	} {
		t.Run(family, func(t *testing.T) {
			li := &LinuxInstaller{Platform: &platform.Platform{DistroFamily: family}}

			var mpvPkg, celluloidPkg bool
			for _, m := range li.GetAvailableMethods(false) {
				if m.ID == constants.MethodMPVPackage {
					mpvPkg = true
				}
				if m.ID == constants.MethodCelluloidPackage {
					celluloidPkg = true
				}
			}
			assert.True(t, mpvPkg, "mpv-package should be offered on %s", family)
			assert.True(t, celluloidPkg, "celluloid-package should be offered on %s", family)
		})
	}
}