package extractor

import (
	"fmt"
	"testing"
)

// mockNode implements the Node interface for testing.
type mockNode struct {
	text     string
	textErr  error
	content  string
	children Nodes
}

func (m mockNode) Content() (string, error)            { return m.content, nil }
func (m mockNode) Text() (string, error)               { return m.text, m.textErr }
func (m mockNode) Attr(_ string) (string, error)       { return "", nil }
func (m mockNode) Screenshot() ([]byte, error)         { return nil, nil }
func (m mockNode) Type(_ string) error                 { return nil }
func (m mockNode) Click() error                        { return nil }
func (m mockNode) Select(_ string) Nodes               { return m.children }
func (m mockNode) SelectFirst(_ string) Node           { return m.children.First() }
func (m mockNode) ForEach(_ string, _ func(Node) error) error { return nil }
func (m mockNode) SetHidden(_ bool) error              { return nil }
func (m mockNode) SetAttribute(_, _ string) error      { return nil }

func TestNodes_First_Empty(t *testing.T) {
	var nodes Nodes
	got := nodes.First()
	if got != nil {
		t.Errorf("First() on empty Nodes = %v, want nil", got)
	}
}

func TestNodes_First_NonEmpty(t *testing.T) {
	n1 := mockNode{text: "first"}
	n2 := mockNode{text: "second"}
	nodes := Nodes{n1, n2}

	got := nodes.First()
	if got == nil {
		t.Fatal("First() on non-empty Nodes returned nil")
	}

	text, _ := got.Text()
	if text != "first" {
		t.Errorf("First().Text() = %q, want %q", text, "first")
	}
}

func TestNodes_Select(t *testing.T) {
	child1 := mockNode{text: "child1"}
	child2 := mockNode{text: "child2"}
	child3 := mockNode{text: "child3"}

	n1 := mockNode{children: Nodes{child1, child2}}
	n2 := mockNode{children: Nodes{child3}}

	nodes := Nodes{n1, n2}
	result := nodes.Select("anything")

	if len(result) != 3 {
		t.Errorf("Select() returned %d nodes, want 3", len(result))
	}
}

func TestNodes_Select_Empty(t *testing.T) {
	var nodes Nodes
	result := nodes.Select("anything")
	if len(result) != 0 {
		t.Errorf("Select() on empty Nodes returned %d nodes, want 0", len(result))
	}
}

func TestNodes_ExtractText(t *testing.T) {
	n1 := mockNode{text: "hello"}
	n2 := mockNode{text: "world"}
	nodes := Nodes{n1, n2}

	texts, err := nodes.ExtractText()
	if err != nil {
		t.Fatalf("ExtractText() error = %v", err)
	}

	if len(texts) != 2 || texts[0] != "hello" || texts[1] != "world" {
		t.Errorf("ExtractText() = %v, want [hello world]", texts)
	}
}

func TestNodes_ExtractText_Error(t *testing.T) {
	n1 := mockNode{text: "hello"}
	n2 := mockNode{textErr: fmt.Errorf("text error")}
	nodes := Nodes{n1, n2}

	_, err := nodes.ExtractText()
	if err == nil {
		t.Fatal("ExtractText() expected error, got nil")
	}
}

func TestNodes_ExtractText_Empty(t *testing.T) {
	var nodes Nodes
	texts, err := nodes.ExtractText()
	if err != nil {
		t.Fatalf("ExtractText() error = %v", err)
	}
	if len(texts) != 0 {
		t.Errorf("ExtractText() on empty = %v, want empty", texts)
	}
}