package archive

import (
	"log"
	"strings"
	"io/ioutil"
	"path/filepath"
	"hash/fnv"
	"../config"
)

var pln = log.Println

var Archive_map map[uint32]config.Track_t
var Archive_map_keys []uint32

var built = false

func Build() error {

	if built {
		return nil
	}

	Archive_map = make(map[uint32]config.Track_t)

	album_dirs, err := ioutil.ReadDir(config.Xcfg.Archive.PATH)	
	if err != nil {
		return err
	}

	for _, dir := range album_dirs {

		album := new(config.Album_t)		
		album.TRACKS = make(map[uint32]config.Track_t)
		album.PATH = filepath.Join(config.Xcfg.Archive.PATH, dir.Name())
		album.ID = hash(album.PATH)

		album.MAKER, album.NAME = parse_album_name(dir.Name())

		track_files, _ := filepath.Glob(album.PATH + "/*.mp3")
		for _, file := range track_files {
			track := new(config.Track_t)
			track.NAME = parse_track_name(filepath.Base(file), album.MAKER, album.NAME)
			track.MAKER = album.MAKER
			track.ALBUM = album.NAME
			track.PATH = file
			track.ID = hash(track.PATH)
			track.AID = album.ID

			album.TRACKS[track.ID] = *track

			Archive_map[track.ID] = *track
			Archive_map_keys = append(Archive_map_keys, track.ID)			

		}

		cover, _ := filepath.Glob(album.PATH + "/*.jpg")
		if len(cover) > 0 {
			album.COVER = filepath.Join(album.PATH, cover[0])
		}

		// print_album(album)

		config.Xcfg.Archive.ALBUMS[album.ID] = *album
	}

	built = true
	return nil
}

func parse_album_name(name string) (string, string) {
	chunks := strings.Split(name, " - ")
	if len(chunks) >= 2 {
		return chunks[0], chunks[1]
	}
	return chunks[0], "n/a"
}

func print_album(a *config.Album_t) {
	pln(a.MAKER)
	pln(a.NAME)
	pln(a.PATH)
	pln(a.COVER)
	pln(a.ID)
	pln(len(a.TRACKS))
	pln("-----")
	for _, t := range a.TRACKS {
		print_track(t)
	}
}

// ex.: Electronic Works 1958-1995-002-Else Marie Pade-Faust Suite Faust & Mefisto.mp3
func parse_track_name(name string, maker string, album string) string {

	chunks := []string{}
	if strings.HasPrefix(name, album) {								// bleep
		chunks = strings.Split(name, "-" + maker + "-")
	} else if strings.HasPrefix(name, maker) {						// bandcamp
		chunks = strings.Split(name, " - " + album + " - ")
	}

	if len(chunks) >= 2 {
		return strings.Split(chunks[1], ".")[0]
	}
	return "n/a"		
}

func print_track(t config.Track_t) {

	pln("	" + t.NAME)
	pln("	" + t.PATH)
	pln(t.ID)
	pln(t.AID)
	pln("////////")
	
}


func hash(s string) uint32 {
        h := fnv.New32a()
        h.Write([]byte(s))
        return h.Sum32()
}