package lol

import (
	"errors"
	"testing"
)

func TestLevelNames(t *testing.T) {
	if len(LevelNames) != 7 {
		t.Fatalf("expected 7 levels, got %d", len(LevelNames))
	}
}

func TestSetLevel(t *testing.T) {
	old := GetLevel()
	defer SetLevel(old)
	SetLevel(Trace)
	if GetLevel() != Trace {
		t.Fatal("expected Trace")
	}
	SetLevel(Off)
	if GetLevel() != Off {
		t.Fatal("expected Off")
	}
}

func TestSetLevelByName(t *testing.T) {
	old := GetLevel()
	defer SetLevel(old)
	SetLevelByName([]byte("debug"))
	if GetLevel() != Debug {
		t.Fatalf("expected Debug(%d), got %d", Debug, GetLevel())
	}
	SetLevelByName([]byte("bogus"))
	if GetLevel() != Info {
		t.Fatalf("expected Info(%d) for unknown name, got %d", Info, GetLevel())
	}
}

func TestGetLevelByName(t *testing.T) {
	if GetLevelByName([]byte("trace")) != Trace {
		t.Fatal("expected Trace")
	}
	if GetLevelByName([]byte("nope")) != Info {
		t.Fatal("expected Info for unknown")
	}
}

func TestPrintersWithChannel(t *testing.T) {
	ch := chan []byte{64}
	SetLevel(Trace)
	defer SetLevel(Info)
	Init(ch)
	defer Init(nil)

	Main.Log.I.Ln("hello", "world")

	select {
	case entry := <-ch:
		if len(entry) == 0 {
			t.Fatal("empty entry")
		}
		// Should contain INF tag and the message
		s := string(entry)
		if !contains(s, "INF") {
			t.Fatalf("missing INF tag in: %s", s)
		}
		if !contains(s, "helloworld") {
			t.Fatalf("missing message in: %s", s)
		}
	default:
		t.Fatal("no entry received on channel")
	}
}

func TestPrintersF(t *testing.T) {
	ch := chan []byte{64}
	SetLevel(Trace)
	defer SetLevel(Info)
	Init(ch)
	defer Init(nil)

	Main.Log.I.F([]byte("count=%d"), 42)

	select {
	case entry := <-ch:
		s := string(entry)
		if !contains(s, "count=42") {
			t.Fatalf("missing formatted message in: %s", s)
		}
	default:
		t.Fatal("no entry received")
	}
}

func TestChk(t *testing.T) {
	ch := chan []byte{64}
	SetLevel(Trace)
	defer SetLevel(Info)
	Init(ch)
	defer Init(nil)

	if Main.Check.E(nil) {
		t.Fatal("nil error should return false")
	}

	err := errors.New("test error")
	if !Main.Check.E(err) {
		t.Fatal("non-nil error should return true")
	}

	select {
	case entry := <-ch:
		if !contains(string(entry), "test error") {
			t.Fatalf("missing error text in: %s", string(entry))
		}
	default:
		t.Fatal("no entry for error check")
	}
}

func TestLevelSuppression(t *testing.T) {
	ch := chan []byte{64}
	SetLevel(Error)
	defer SetLevel(Info)
	Init(ch)
	defer Init(nil)

	Main.Log.D.Ln("suppressed")

	select {
	case entry := <-ch:
		t.Fatalf("debug should be suppressed at Error level, got: %s", string(entry))
	default:
		// good — nothing sent
	}
}

func TestErrorf(t *testing.T) {
	ch := chan []byte{64}
	SetLevel(Trace)
	defer SetLevel(Info)
	Init(ch)
	defer Init(nil)

	err := Main.Errorf.E([]byte("fail: %d"), 99)
	if err == nil {
		t.Fatal("expected error")
	}
	if err.Error() != "fail: 99" {
		t.Fatalf("wrong error: %s", err.Error())
	}
}

func contains(s, sub string) bool {
	for i := 0; i <= len(s)-len(sub); i++ {
		if s[i:i+len(sub)] == sub {
			return true
		}
	}
	return false
}