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
	Disc        int
	TotalDiscs  int
	Comment     string
}

func ReadAudioTags(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()
	disc, totalDiscs := m.Disc()

	info := &Metadata{
		Title:       m.Title(),
		Artist:      parseSeperatedTag(m.Artist()),
		Album:       m.Album(),
		AlbumArtist: parseSeperatedTag(m.AlbumArtist()),
		Track:       track,
		TotalTracks: totalTracks,
		Disc:        disc,
		TotalDiscs:  totalDiscs,
		Comment:     m.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

}