package backend

import (
	"io/fs"
	"os"
	"testing"
	"time"
)

func TestContains(t *testing.T) {
	tests := []struct {
		name      string
		slice     []string
		search    string
		expected  bool
	}{
		{
			name:     "element exists",
			slice:    []string{"a", "b", "c"},
			search:   "b",
			expected: true,
		},
		{
			name:     "element does not exist",
			slice:    []string{"a", "b", "c"},
			search:   "d",
			expected: false,
		},
		{
			name:     "empty slice",
			slice:    []string{},
			search:   "a",
			expected: false,
		},
		{
			name:     "element at start",
			slice:    []string{"a", "b", "c"},
			search:   "a",
			expected: true,
		},
		{
			name:     "element at end",
			slice:    []string{"a", "b", "c"},
			search:   "c",
			expected: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := contains(tt.slice, tt.search)
			if result != tt.expected {
				t.Errorf("contains() = %v, want %v", result, tt.expected)
			}
		})
	}
}

func TestIsSong(t *testing.T) {
	mockFileInfo := &mockFileInfoForSong{name: "test.mp3", isDir: false, size: 100}

	result := isSong(mockFileInfo)
	if !result {
		t.Error("isSong() should return true for .mp3 file")
	}

	mockFileInfo2 := &mockFileInfoForSong{name: "test.txt", isDir: false, size: 100}
	result = isSong(mockFileInfo2)
	if result {
		t.Error("isSong() should return false for .txt file")
	}

	mockFileInfo3 := &mockFileInfoForSong{name: "test", isDir: true, size: 100}
	result = isSong(mockFileInfo3)
	if result {
		t.Error("isSong() should return false for directory")
	}
}

func TestIsCoverImage(t *testing.T) {
	tests := []struct {
		name     string
		fileInfo fs.FileInfo
		expected bool
	}{
		{
			name:     "cover.jpg",
			fileInfo: &mockFileInfoForCover{name: "cover.jpg", isDir: false, size: 100},
			expected: true,
		},
		{
			name:     "cover.png",
			fileInfo: &mockFileInfoForCover{name: "cover.png", isDir: false, size: 100},
			expected: true,
		},
		{
			name:     "my_cover.jpg",
			fileInfo: &mockFileInfoForCover{name: "my_cover.jpg", isDir: false, size: 100},
			expected: true,
		},
		{
			name:     "image.jpg",
			fileInfo: &mockFileInfoForCover{name: "image.jpg", isDir: false, size: 100},
			expected: false,
		},
		{
			name:     "cover.txt",
			fileInfo: &mockFileInfoForCover{name: "cover.txt", isDir: false, size: 100},
			expected: false,
		},
		{
			name:     "directory",
			fileInfo: &mockFileInfoForCover{name: "cover", isDir: true, size: 100},
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := isCoverImage(tt.fileInfo)
			if result != tt.expected {
				t.Errorf("isCoverImage() = %v, want %v", result, tt.expected)
			}
		})
	}
}

func TestGetIdFromFileNew(t *testing.T) {
	tests := []struct {
		name     string
		fileInfo os.FileInfo
		expected int32
	}{
		{
			name:     "valid id file",
			fileInfo: &mockFileInfoForId{name: ".123.id", isDir: false, size: 100},
			expected: 123,
		},
		{
			name:     "invalid id file (directory)",
			fileInfo: &mockFileInfoForId{name: ".123.id", isDir: true, size: 100},
			expected: -1,
		},
		{
			name:     "invalid id file (no .id extension)",
			fileInfo: &mockFileInfoForId{name: "123.txt", isDir: false, size: 100},
			expected: -1,
		},
		{
			name:     "invalid id file (not a number)",
			fileInfo: &mockFileInfoForId{name: ".abc.id", isDir: false, size: 100},
			expected: 0, // strconv.Atoi returns 0 for invalid numbers (error is ignored)
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := getIdFromFileNew(tt.fileInfo)
			if result != tt.expected {
				t.Errorf("getIdFromFileNew() = %v, want %v", result, tt.expected)
			}
		})
	}
}

// Mock types for testing
type mockFileInfoForSong struct {
	name  string
	isDir bool
	size  int64
}

func (m *mockFileInfoForSong) Name() string       { return m.name }
func (m *mockFileInfoForSong) Size() int64        { return m.size }
func (m *mockFileInfoForSong) Mode() os.FileMode   { return 0 }
func (m *mockFileInfoForSong) ModTime() time.Time  { return time.Time{} }
func (m *mockFileInfoForSong) IsDir() bool         { return m.isDir }
func (m *mockFileInfoForSong) Sys() interface{}    { return nil }

type mockFileInfoForCover struct {
	name  string
	isDir bool
	size  int64
}

func (m *mockFileInfoForCover) Name() string       { return m.name }
func (m *mockFileInfoForCover) Size() int64        { return m.size }
func (m *mockFileInfoForCover) Mode() os.FileMode   { return 0 }
func (m *mockFileInfoForCover) ModTime() time.Time  { return time.Time{} }
func (m *mockFileInfoForCover) IsDir() bool         { return m.isDir }
func (m *mockFileInfoForCover) Sys() interface{}    { return nil }

type mockFileInfoForId struct {
	name  string
	isDir bool
	size  int64
}

func (m *mockFileInfoForId) Name() string       { return m.name }
func (m *mockFileInfoForId) Size() int64        { return m.size }
func (m *mockFileInfoForId) Mode() os.FileMode   { return 0 }
func (m *mockFileInfoForId) ModTime() time.Time  { return time.Time{} }
func (m *mockFileInfoForId) IsDir() bool         { return m.isDir }
func (m *mockFileInfoForId) Sys() interface{}    { return nil }