package main

import (
	"context"
	"flag"
	"log"
	"slices"

	"git.gensokyo.uk/yonah/monstersirenfetch"
)

var (
	flagAlbumsPath string
	flagSongsPath  string
	flagOutputPath string
)

func init() {
	flag.StringVar(&flagAlbumsPath, "a", "albums.json",
		"Path to file containing the response body of /api/albums")
	flag.StringVar(&flagSongsPath, "s", "songs.json",
		"Path to file containing the response body of /api/songs")
	flag.StringVar(&flagOutputPath, "o", "composite.json",
		"Path to write composite data")
}

func mustEnrich(ctx context.Context) {
	var (
		albumsResponse monstersirenfetch.AlbumsResponse
		songsResponse  monstersirenfetch.SongsResponse
	)
	mustReadJSON(flagAlbumsPath, &albumsResponse)
	mustReadJSON(flagSongsPath, &songsResponse)

	if c, err := monstersirenfetch.Flatten(albumsResponse.Data, songsResponse.Data); err != nil {
		log.Fatal(err)
	} else {
		n := new(netDirect)
		for _, ca := range c {
			if ca.Album == nil {
				log.Fatal("albums contains nil")
			}

			if !ca.Album.IsFull() {
				if err = ca.Album.Enrich(ctx, n); err != nil {
					log.Fatal(err)
				}
				log.Printf("enriched album %s (%s) with %d songs", ca.Album.CID.String(), ca.Album.Name, len(ca.Songs))
			} else {
				log.Printf("skipped album %s (%s)", ca.Album.CID.String(), ca.Album.Name)
			}

			// consistency check: for later validating enriched songs against flatten
			flattenSongs := make([]monstersirenfetch.AlbumSong, 0, len(ca.Songs))

			for _, cs := range ca.Songs {
				if cs == nil {
					log.Fatal("songs contains nil")
				}
				flattenSongs = append(flattenSongs, monstersirenfetch.AlbumSong{CID: cs.CID, Name: cs.Name, Artists: cs.Artists})

				if !cs.IsFull() {
					if err = cs.Enrich(ctx, n); err != nil {
						log.Fatal(err)
					}
					log.Printf("enriched song %s: %s (%s)", cs.CID.String(), cs.SourceURL, cs.Name)
				} else {
					log.Printf("skipped song %s: %s (%s)", cs.CID.String(), cs.SourceURL, cs.Name)
				}
			}

			// consistency check: enriched songs match flattened songs
			slices.SortFunc(flattenSongs, func(a, b monstersirenfetch.AlbumSong) int { return int(a.CID - b.CID) })
			enrichSongs := make([]monstersirenfetch.AlbumSong, len(ca.Album.Songs))
			copy(enrichSongs, ca.Album.Songs)
			slices.SortFunc(enrichSongs, func(a, b monstersirenfetch.AlbumSong) int { return int(a.CID - b.CID) })
			if !slices.EqualFunc(flattenSongs, enrichSongs, func(a monstersirenfetch.AlbumSong, b monstersirenfetch.AlbumSong) bool {
				return a.CID == b.CID && a.Name == b.Name && slices.Equal(a.Artists, b.Artists)
			}) {
				log.Fatalf("album %s enrichment inconsistent with flatten state", ca.Album.Name)
			} else {
				log.Printf("validated %d songs associated with album %s", len(enrichSongs), ca.Album.CID.String())
			}
		}
		mustWriteJSON(flagOutputPath, c)
		log.Println("composite data written to", flagOutputPath)
	}
}