package state

import (
        "path/filepath"
        "testing"
)

func TestOpenAndJournal(t *testing.T) {
        mgr, err := Open(filepath.Join(t.TempDir(), "state.db"))
        if err != nil {
                t.Fatal(err)
        }
        defer mgr.Close()

        if err := mgr.RecordJournal(JournalEntry{
                SpellName: "wget", Variant: "v1",
                Status: StateCasting,
        }); err != nil {
                t.Fatal(err)
        }
        got, err := mgr.GetJournal("wget", "v1")
        if err != nil {
                t.Fatal(err)
        }
        if got == nil || got.Status != StateCasting {
                t.Fatalf("unexpected journal entry: %+v", got)
        }
}

func TestTablet(t *testing.T) {
        mgr, _ := Open(filepath.Join(t.TempDir(), "state.db"))
        defer mgr.Close()

        if _, ok := mgr.GetTablet("wget", "ssl"); ok {
                t.Fatal("tablet should be empty initially")
        }
        if err := mgr.SaveTablet("wget", "ssl", true); err != nil {
                t.Fatal(err)
        }
        val, ok := mgr.GetTablet("wget", "ssl")
        if !ok || !val {
                t.Fatalf("expected ssl=true, got %v (%v)", val, ok)
        }
        answers := mgr.ListTablet("wget")
        if len(answers) != 1 || !answers["ssl"] {
                t.Fatalf("ListTablet: %+v", answers)
        }
}

func TestManifestAndWhoOwns(t *testing.T) {
        mgr, _ := Open(filepath.Join(t.TempDir(), "state.db"))
        defer mgr.Close()

        files := []string{"/usr/bin/wget", "/usr/share/man/wget.1"}
        if err := mgr.SaveManifest("wget", "v1", files); err != nil {
                t.Fatal(err)
        }
        got, err := mgr.GetManifest("wget", "v1")
        if err != nil {
                t.Fatal(err)
        }
        if len(got) != 2 {
                t.Fatalf("expected 2 files, got %d", len(got))
        }
        spell, variant, err := mgr.WhoOwns("/usr/bin/wget")
        if err != nil || spell != "wget" || variant != "v1" {
                t.Fatalf("WhoOwns: %s %s %v", spell, variant, err)
        }
}

func TestRecover(t *testing.T) {
        mgr, _ := Open(filepath.Join(t.TempDir(), "state.db"))
        defer mgr.Close()

        _ = mgr.RecordJournal(JournalEntry{SpellName: "a", Variant: "v", Status: StateCasting})
        _ = mgr.RecordJournal(JournalEntry{SpellName: "b", Variant: "v", Status: StateInstalled})
        _ = mgr.RecordJournal(JournalEntry{SpellName: "c", Variant: "v", Status: StateFailed})

        pending, err := mgr.Recover()
        if err != nil {
                t.Fatal(err)
        }
        // Only "a" should be pending (Casting). "b" is Installed, "c" is Failed.
        if len(pending) != 1 || pending[0].SpellName != "a" {
                t.Fatalf("Recover: %+v", pending)
        }
}