package motd

import (
	"reflect"
	"testing"
)

func TestDiffToggleOnly(t *testing.T) {
	current := []Script{{Name: "00-header", Enabled: true}, {Name: "10-sysinfo", Enabled: false}}
	desired := []DesiredEntry{{Name: "00-header", Enabled: false}, {Name: "10-sysinfo", Enabled: false}}

	plan := Diff(current, desired)
	if len(plan.Chmod) != 1 || plan.Chmod[0].Name != "00-header" || plan.Chmod[0].Enable {
		t.Errorf("Chmod = %+v, want 00-header disable", plan.Chmod)
	}
	if plan.Empty() {
		t.Error("Plan sollte eine Operation haben, ist aber leer")
	}
	if len(plan.Renames) != 0 {
		t.Errorf("Renames = %+v, want none", plan.Renames)
	}
}

func TestDiffReorderRenumbers(t *testing.T) {
	current := []Script{
		{Name: "00-a", Enabled: true},
		{Name: "10-b", Enabled: true},
		{Name: "20-c", Enabled: true},
	}
	desired := []DesiredEntry{
		{Name: "10-b", Enabled: true},
		{Name: "00-a", Enabled: true},
		{Name: "20-c", Enabled: true},
	}

	plan := Diff(current, desired)
	want := []RenameOp{{From: "10-b", To: "00-b"}, {From: "00-a", To: "10-a"}}
	if !reflect.DeepEqual(plan.Renames, want) {
		t.Errorf("Renames = %+v, want %+v", plan.Renames, want)
	}
}

func TestDiffKeepsPrefixesWhenOrderUnchanged(t *testing.T) {
	current := []Script{{Name: "05-a", Enabled: true}, {Name: "07-b", Enabled: true}}
	desired := []DesiredEntry{{Name: "05-a", Enabled: true}, {Name: "07-b", Enabled: true}}

	if plan := Diff(current, desired); !plan.Empty() {
		t.Errorf("Plan = %+v, want leer", plan)
	}
}

func TestDiffInstallAndRemove(t *testing.T) {
	current := []Script{
		{Name: "00-header", Enabled: true},
		{Name: "95-footer", Enabled: true, Bundled: true},
	}
	desired := []DesiredEntry{
		{Name: "00-header", Enabled: true},
		{Name: "10-brand-header", Enabled: true, Install: "brand-header"},
		{Name: "95-footer", Remove: true},
	}

	plan := Diff(current, desired)
	if len(plan.Installs) != 1 || plan.Installs[0].Source != "brand-header" {
		t.Errorf("Installs = %+v", plan.Installs)
	}
	if len(plan.Removes) != 1 || plan.Removes[0].Name != "95-footer" {
		t.Errorf("Removes = %+v", plan.Removes)
	}
}

func TestDesiredFromPresetInterleavesUnlisted(t *testing.T) {
	current := []Script{
		{Name: "00-header", Enabled: true},
		{Name: "50-motd-news", Enabled: true},
		{Name: "90-updates-available", Enabled: false},
		{Name: "95-footer", Enabled: true, Bundled: true},
	}
	entries := []DesiredEntry{
		{Name: "10-brand-header", Enabled: true, Install: "brand-header"},
		{Name: "00-header", Enabled: false},
	}

	got := DesiredFromPreset(current, entries)
	var names []string
	var removes []string
	for _, e := range got {
		if e.Remove {
			removes = append(removes, e.Name)
		} else {
			names = append(names, e.Name)
		}
	}
	wantNames := []string{"10-brand-header", "00-header", "50-motd-news", "90-updates-available"}
	if !reflect.DeepEqual(names, wantNames) {
		t.Errorf("Reihenfolge = %v, want %v", names, wantNames)
	}
	if !reflect.DeepEqual(removes, []string{"95-footer"}) {
		t.Errorf("Removes = %v, want [95-footer]", removes)
	}
	// Ungelistete behalten ihren Zustand.
	for _, e := range got {
		if e.Name == "50-motd-news" && !e.Enabled {
			t.Error("50-motd-news sollte aktiviert bleiben")
		}
		if e.Name == "00-header" && e.Enabled {
			t.Error("00-header sollte laut Preset deaktiviert werden")
		}
	}
}

func TestDesiredFromPresetSkipsMissing(t *testing.T) {
	current := []Script{{Name: "00-header", Enabled: true}}
	entries := []DesiredEntry{{Name: "10-gibt-es-nicht", Enabled: true}}

	got := DesiredFromPreset(current, entries)
	if len(got) != 1 || got[0].Name != "00-header" {
		t.Errorf("got %+v", got)
	}
}