package metadata

import (
	"fmt"
	"log/slog"
	"os"
	"path/filepath"
	"regexp"
	"slices"
	"sort"
	"strings"

	"git.kapelle.org/niklas/ripsort/internal/clients/musicbrainz"
	"github.com/dhowden/tag"
)

type Metadata struct {
	Title       *string
	Artist      []string
	Album       *string
	AlbumArtist []string
	Track       int
	TotalTracks int
	Comment     *string
	ISRC        *string
	Date        *string
	Genre       []string
	SpotifyID   *string
}

func ReadAudioTags(filePath string) (*Metadata, error) {
	ext := strings.ToLower(filepath.Ext(filePath))

	switch {
	case ext == ".flac":
		return readVorbisMetadata(filePath)
	default:
		return readGenericAudioTags(filePath)
	}
}

func readGenericAudioTags(filePath string) (*Metadata, error) {
	f, err := os.Open(filePath)
	if err != nil {
		return nil, fmt.Errorf("failed to open file: %w", err)
	}
	defer f.Close()

	m, err := tag.ReadFrom(f)
	if err != nil {
		return nil, fmt.Errorf("failed to read tags: %w", err)
	}

	track, totalTracks := m.Track()

	title := m.Title()
	album := m.Album()
	comment := m.Comment()

	info := &Metadata{
		Title:       &title,
		Artist:      parseSeperatedTag(m.Artist()),
		Album:       &album,
		AlbumArtist: parseSeperatedTag(m.AlbumArtist()),
		Track:       track,
		TotalTracks: totalTracks,
		Comment:     &comment,
		Genre:       []string{m.Genre()},
	}

	commentToSpotifyid(info)

	return info, nil
}

func parseSeperatedTag(s string) []string {
	parsed := make([]string, 0)

	for element := range strings.SplitSeq(s, ";") {
		parsed = append(parsed, strings.TrimSpace(element))
	}

	return parsed
}

func UpdateMetadata(src, dst string, m Metadata) error {

	ext := strings.ToLower(filepath.Ext(src))

	switch {
	case ext == ".flac":
		return updateFlacMetadata(m, src, dst)
	default:
		slog.Warn("Unsupported format for updating metadata")
	}

	return nil

}

func commentToSpotifyid(m *Metadata) {
	var re = regexp.MustCompile(`(?m)(https:\/\/open\.spotify\.com\/track\/)(.*)`)

	if m.Comment == nil {
		return
	}

	matches := re.FindAllStringSubmatch(*m.Comment, -1)

	if len(matches) != 1 {
		return
	}

	id := matches[0][2]

	m.SpotifyID = &id
}

func SearchForGenre(mbc *musicbrainz.MusicBrainzClient, m *Metadata) ([]string, error) {
	if m.ISRC == nil {
		return []string{}, nil
	}

	res, err := mbc.SearchByISRC(*m.ISRC, musicbrainz.SearchOptions{})
	if err != nil {
		return []string{}, err
	}

	if len(res.Recordings) == 0 {
		return []string{}, nil
	}

	allTags := []musicbrainz.Tag{}

	for _, rec := range res.Recordings {
		allTags = append(allTags, rec.Tags...)
	}

	sort.Slice(allTags[:], func(i int, j int) bool {
		return allTags[i].Count > allTags[j].Count
	})

	allTags = slices.CompactFunc(allTags, func(lhs, rhs musicbrainz.Tag) bool {
		return lhs.Name == rhs.Name
	})

	finalTags := []string{}
	for _, tag := range allTags {
		finalTags = append(finalTags, tag.Name)
	}

	return finalTags, nil
}