package main

import (
	"fmt"
	"io"
	"log"
	"os"
	"path/filepath"
	"time"

	"launchpad.net/go-xdg/v0"
)

// Execute executes the job
func Execute() error {
	if len(os.Args) != 2 {
		return fmt.Errorf("Missing mandatory .csv parameter")
	}

	albums := make(chan *Album, 10000)
	errors := make(chan error, 10)
	parsed := make(chan bool, 10000)
	cached := make(chan bool, 1000)
	cacheBase, err := xdg.Cache.Ensure(filepath.Join("org.satellite.satbd", "test"))
	if err != nil {
		return err
	}
	cacheBase = filepath.Dir(cacheBase)
	c, err := NewAlbumDescriptionCache(cacheBase, 10, 10*time.Second)
	if err != nil {
		return err
	}
	start := time.Now()
	go func() {
		defer close(albums)
		csvFile, err := os.Open(os.Args[1])
		if err != nil {
			errors <- err
			return
		}
		defer csvFile.Close()
		csvReader, err := NewAlbumCsvReader(csvFile)
		if err != nil {
			errors <- err
			return
		}

		for {
			a, err := csvReader.Read()
			if err != nil {
				if err == io.EOF {
					break
				}
				errors <- err
			}
			parsed <- true
			albums <- a
		}
		fmt.Printf("Done parsing albums in %s\n\n", time.Since(start))
	}()

	go func() {
		defer close(errors)
		for {
			a, ok := <-albums
			if ok == false {
				break
			}
			_, err := c.GetDescription(a.ID)
			cached <- true
			if err != nil {
				errors <- err
			}
		}
		fmt.Printf("DONE caching in %s\n\n", time.Since(start))
	}()

	pCount := 0
	cCount := 0
	errCount := 0
	done := false
	for done == false {
		select {
		case err, ok := <-errors:
			if ok == false {
				done = true
			} else {
				errCount++
			}
			if err != nil {
				fmt.Printf("\033[1A\033[KGot error: %s\n\n", err)
			}
		case <-parsed:
			pCount++
		case <-cached:
			cCount++
		}
		fmt.Printf("\033[1A\033[K%d/%d (errors:%d)\n", cCount, pCount, errCount)
	}
	return nil
}

func main() {
	if err := Execute(); err != nil {
		log.Printf("got unhandled error: %s", err)
		os.Exit(1)
	}
}