package main

import (
	"errors"
	"testing"
)

type MockCommand struct {
	output string
	err    error
}

func NewMockCommand(output string) *MockCommand {
	return &MockCommand{output: output}
}

func NewMockCommandWithError(err error) *MockCommand {
	return &MockCommand{err: err}
}

func (m *MockCommand) Execute(binary string, args ...string) ([]byte, error) {
	if m.err != nil {
		return nil, m.err
	}
	return []byte(m.output), nil
}

func TestGetGPUInfo(t *testing.T) {
	mockOutput := `Graphics/Displays:
            Apple M2:
              Total Number of Cores: 10`

	cmd := NewMockCommand(mockOutput)

	result, err := getGPUInfo(cmd)
	if err != nil {
		t.Fatalf("Expected no error, got: %v", err)
	}

	expected := CoreCount(10)
	if result != expected {
		t.Errorf("Expected %d GPU cores, got %d", expected, result)
	}
}

func TestGetGPUInfoNotFound(t *testing.T) {
	mockOutput := `Graphics/Displays:
            Apple M2:
              Some other field: 10`

	cmd := NewMockCommand(mockOutput)

	_, err := getGPUInfo(cmd)
	if err == nil {
		t.Fatal("Expected error when GPU cores not found, got nil")
	}
}

func TestGetCPUInfoSuccess(t *testing.T) {
	mockOutput := "Apple M2\n8\n4\n4\n"
	cmd := NewMockCommand(mockOutput)

	brand, cores, pCores, eCores, err := getCPUInfo(cmd)
	if err != nil {
		t.Fatalf("Expected no error, got: %v", err)
	}

	if brand != "Apple M2" {
		t.Errorf("Expected brand 'Apple M2', got '%s'", brand)
	}
	if cores != 8 {
		t.Errorf("Expected 8 cores, got %d", cores)
	}
	if pCores != 4 {
		t.Errorf("Expected 4 performance cores, got %d", pCores)
	}
	if eCores != 4 {
		t.Errorf("Expected 4 efficiency cores, got %d", eCores)
	}
}

func TestGetCPUInfoMissingCoreCount(t *testing.T) {
	mockOutput := "Apple M2\n"
	cmd := NewMockCommand(mockOutput)

	_, _, _, _, err := getCPUInfo(cmd)
	if err == nil {
		t.Fatal("Expected error with insufficient output, got nil")
	}
}

func TestGetCPUInfoInvalidCoreCount(t *testing.T) {
	mockOutput := "Apple M2\ninvalid\n4\n4\n"
	cmd := NewMockCommand(mockOutput)

	_, _, _, _, err := getCPUInfo(cmd)
	if err == nil {
		t.Fatal("Expected error with invalid core count, got nil")
	}
}

func TestFromBrandString(t *testing.T) {
	tests := []struct {
		brand    string
		expected AppleChip
	}{
		{"Apple M1", M1},
		{"Apple M1 Pro", M1Pro},
		{"Apple M1 Max", M1Max},
		{"Apple M1 Ultra", M1Ultra},
		{"Apple M2", M2},
		{"Apple M2 Pro", M2Pro},
		{"Apple M2 Max", M2Max},
		{"Apple M2 Ultra", M2Ultra},
		{"Apple M3", M3},
		{"Apple M3 Pro", M3Pro},
		{"Apple M3 Max", M3Max},
		{"Intel Core i7", Unknown},
	}

	for _, test := range tests {
		result := fromBrandString(test.brand)
		if result != test.expected {
			t.Errorf("For brand '%s', expected %v, got %v", test.brand, test.expected, result)
		}
	}
}

func TestChipGetSpecs(t *testing.T) {
	tests := []struct {
		chip     AppleChip
		expected ChipSpecs
	}{
		{M1, ChipSpecs{CPUTDP: 20, GPUTDP: 20, CPUBW: 70, GPUBW: 70}},
		{M1Pro, ChipSpecs{CPUTDP: 30, GPUTDP: 30, CPUBW: 200, GPUBW: 200}},
		{M2, ChipSpecs{CPUTDP: 25, GPUTDP: 15, CPUBW: 100, GPUBW: 100}},
		{Unknown, ChipSpecs{CPUTDP: 0, GPUTDP: 0, CPUBW: 0, GPUBW: 0}},
	}

	for _, test := range tests {
		result := test.chip.getSpecs()
		if result != test.expected {
			t.Errorf("For chip %v, expected %+v, got %+v", test.chip, test.expected, result)
		}
	}
}

func TestNewSocInfoWithCommand(t *testing.T) {
	sysctlOutput := "Apple M2\n8\n4\n4\n"

	profilerOutput := `Graphics/Displays:
            Apple M2:
              Total Number of Cores: 10`

	cmd := &MockCommandMultiple{
		outputs: map[string]string{
			"/usr/sbin/sysctl":          sysctlOutput,
			"/usr/sbin/system_profiler": profilerOutput,
		},
	}

	socInfo, err := NewSocInfoWithCommand(cmd)
	if err != nil {
		t.Fatalf("Expected no error, got: %v", err)
	}

	if socInfo.CPUBrandName != "Apple M2" {
		t.Errorf("Expected CPU brand 'Apple M2', got '%s'", socInfo.CPUBrandName)
	}
	if socInfo.NumCPUCores != 8 {
		t.Errorf("Expected 8 CPU cores, got %d", socInfo.NumCPUCores)
	}
	if socInfo.NumGPUCores != 10 {
		t.Errorf("Expected 10 GPU cores, got %d", socInfo.NumGPUCores)
	}
	if socInfo.CPUMaxPower == nil || *socInfo.CPUMaxPower != 25 {
		t.Errorf("Expected CPU max power 25W, got %v", socInfo.CPUMaxPower)
	}
}

type MockCommandMultiple struct {
	outputs map[string]string
	err     error
}

func (m *MockCommandMultiple) Execute(binary string, args ...string) ([]byte, error) {
	if m.err != nil {
		return nil, m.err
	}

	output, exists := m.outputs[binary]
	if !exists {
		return nil, errors.New("binary not found in mock")
	}

	return []byte(output), nil
}