package meta

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestKey(t *testing.T) {
	assert.Equal(t, "the beatles", Key("  The_Beatles! "))
	assert.Equal(t, Key("Ёлка"), Key("елка"))
	assert.Equal(t, "ac dc", Key("AC/DC"))
	assert.Equal(t, "", Key(" -- "))
}

func TestClean(t *testing.T) {
	assert.Equal(t, "Hello World", Clean("  Hello__World "))
	// «й» из двух кодовых точек (и + кратка) становится одной.
	assert.Equal(t, "й", Clean("й"))
}

func TestSplitArtists(t *testing.T) {
	known := func(k string) bool { return k == "simon garfunkel" }
	names := func(cs []ArtistCredit) []string {
		var out []string
		for _, c := range cs {
			out = append(out, c.Role+":"+c.Name)
		}
		return out
	}
	assert.Equal(t, []string{"main:Simon & Garfunkel"}, names(SplitArtists("Simon & Garfunkel", known)))
	assert.Equal(t, []string{"main:Tom", "main:Jerry"}, names(SplitArtists("Tom & Jerry", known)))
	assert.Equal(t, []string{"main:A", "main:B"}, names(SplitArtists("A; B", nil)))
	assert.Equal(t, []string{"main:A", "main:B", "main:C"}, names(SplitArtists("A, B, C", nil)))
	assert.Equal(t, []string{"main:A", "main:B"}, names(SplitArtists("A, B", func(string) bool { return true })), "already glued name is still split")
	assert.Equal(t, []string{"main:Tyler, the Creator"}, names(SplitArtists("Tyler, the Creator", nil)))
	assert.Equal(t, []string{"main:A", "feat:B", "feat:C"}, names(SplitArtists("A feat. B & C", nil)))
	assert.Equal(t, []string{"main:A"}, names(SplitArtists("A / a", nil)), "duplicates by key are dropped")
	assert.Empty(t, SplitArtists("  ", nil))
}

func TestPatterns(t *testing.T) {
	patterns, err := CompilePatterns([]string{
		`^(?P<skip>_incoming)/`,
		`^(?P<artist>[^/]+)/(?P<year>\d{4}) - (?P<album>[^/]+)/(?:(?P<disc>\d)-)?(?P<track>\d{1,3}) - (?P<title>[^/]+)\.\w+$`,
		`^(?P<genre>[^/]+)/(?P<artist>[^/]+)/(?P<album>.+?) \((?P<year>\d{4})\)/(?P<track>\d+)\. (?P<title>[^/]+)\.\w+$`,
	})
	require.NoError(t, err)

	m := MatchPath(patterns, "Кино/1988 - Группа крови/1-01 - Группа крови.flac")
	assert.Equal(t, 1, m.Index)
	assert.Equal(t, map[string]string{
		"artist": "Кино", "year": "1988", "album": "Группа крови", "disc": "1", "track": "01", "title": "Группа крови",
	}, m.Fields)

	m = MatchPath(patterns, "Rock/Queen/Jazz (1978)/03. Jealousy.mp3")
	assert.Equal(t, 2, m.Index)
	assert.Equal(t, "Rock", m.Fields["genre"])

	assert.True(t, MatchPath(patterns, "_incoming/x.mp3").Skip)
	assert.Equal(t, -1, MatchPath(patterns, "loose.mp3").Index)
}

func TestCompilePatternErrors(t *testing.T) {
	for _, bad := range []string{`(?P<artist>[`, `^(?P<band>.+)$`, `^.+$`} {
		_, err := CompilePatterns([]string{`^(?P<title>.+)$`, bad})
		var pe *PatternError
		require.ErrorAs(t, err, &pe, bad)
		assert.Equal(t, 1, pe.Index)
	}
}

func TestMerge(t *testing.T) {
	tags := Fields{Title: "Tag title", Artist: "", Album: "Tag album", Year: "2019-05-01", Track: "3/12"}
	path := Fields{Title: "Path title", Artist: "Path artist", Album: "Path album", Year: "2018", Track: "04"}

	m := Merge(tags, path, true, "x/y.flac")
	assert.Equal(t, "Tag title", m.Title)
	assert.Equal(t, "Path artist", m.Artist, "empty tag falls back to the path")
	assert.Equal(t, "Path artist", m.AlbumArtist, "album artist defaults to the artist")
	assert.Equal(t, 2019, m.Year)
	assert.Equal(t, 3, m.Track)

	m = Merge(tags, path, false, "x/y.flac")
	assert.Equal(t, "Path title", m.Title)
	assert.Equal(t, 2018, m.Year)
	assert.Equal(t, 4, m.Track)

	m = Merge(Fields{Genre: "Rock; Pop/rock"}, Fields{}, true, "Some Folder/07 - My_Song.mp3")
	assert.Equal(t, "My Song", m.Title)
	assert.Equal(t, UnknownArtist, m.Artist)
	assert.Equal(t, "Some Folder", m.Album)
	assert.Equal(t, []string{"Rock", "Pop", "rock"}[:2], m.Genres[:2])
}