// This is designed to be a rather simplistic library to help pull information
// from a local steam library
package steam

import (
	"fmt"
	"io/ioutil"
	"errors"
	"bufio"
	"os"
	"path/filepath"
	"strings"
)

type Library struct {
	Folder string
	Games  map[string]Game
}

type Game struct {
	Name        string
	LibraryPath string
}

func ProcessMultipleLibraries(r []string) ([]*Library, error) {
	var libs []*Library
	for _, i := range r {
		lib := &Library{}
		err := lib.ProcessLibrary(i)
		if err != nil {
			return nil, err
		}
		libs = append(libs, lib)
	}
	return libs, nil
}

func NewLibrary(path string) (*Library, error) {
	l := &Library{}
	err := l.ProcessLibrary(path)
	if err != nil {
		return nil, err
	}
	return l, err
}

func NewLibraryMust(path string) (*Library) {
	l, err := NewLibrary(path)
	if err != nil {
		panic(err)
	}
	return l
}

// Populate the "Folder" and "Games" fields based on the provided directory
func (s *Library) ProcessLibrary(r string) error {
	if !hasCommon(r) {
		return errors.New(fmt.Sprintf("No common directory in: %s", r))
	}

	s.Games = make(map[string]Game)

	dirs, err := ioutil.ReadDir(r + "/common")
	if err != nil {
		return err
	}
	s.Folder = r
	for _, f := range dirs {
		if f.IsDir() {
			s.Games[f.Name()] = Game{
				Name:        f.Name(),
				LibraryPath: r,
			}
			// s.Games = append(s.Games, f.Name())
		}
	}

	return nil
}

// Find the ACF files related to this video game
func FindACF(libraryPath, game string) (string, error) {
	if err := os.Chdir(libraryPath); err != nil {
		return "", err
	}
	files, err := filepath.Glob("*.acf")
	if err != nil {
		return "", err
	}
	for _, fn := range files {
		info, err := os.Lstat(fn)
		if err != nil {
			return "", err
		}
		// We don't want it if it's a directory
		if info.IsDir() {
			continue
		}

		// Open up the file
		f, err := os.Open(fn)
		defer f.Close()
		if err != nil {
			return "", err
		}
		scanner := bufio.NewScanner(f)
		for scanner.Scan() {
			// Finally check and see if the file has the video game name
			if strings.Contains(scanner.Text(), game) {
				return fn, nil
				// fmt.Printf("%s/%s:%d: %s\n", root, path, i, scanner.Text())
			}
		}

	}
	str := "Couldn't find ACF file related to Game: %s"
	return "", errors.New(fmt.Sprintf(str, game))
}

// This is automatically called to print out the contents of the struct
// when things like fmt.Println are used
func (s *Library) String() (str string) {
	str = fmt.Sprintf("Library: %s\n", s.Folder)
	str = str + "----\n"
	for _, v := range s.Games {
		str = str + fmt.Sprintf("%s\n", v.Name)
	}
	return
}

func hasCommon(d string) bool {
	dirs, err := ioutil.ReadDir(d)
	if err != nil {
		return false
	}
	for _, f := range dirs {
		if f.Name() == "common" && f.IsDir() {
			return true
		}
	}
	return false
}