package metadata

import (
	"fmt"
	"log/slog"
	"os"
	"path/filepath"
	"strings"

	"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
}

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,
	}

	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

}