package main

import (
	"database/sql"
	"flag"
	"fmt"
	"os"
	"path/filepath"

	"fagott.pw/grilist/grilist"
	"fagott.pw/grilist/modules/grils"

	_ "github.com/lib/pq"
)

type WrappedGril struct {
	Gril  grils.Gril
	Image string
	Thumb string
}

type GrilReader interface {
	Read(path string) WrappedGril
	ID() int
}

func GetGrilReader(rType string) GrilReader {
	switch rType {
	case "ACD":
		return &ACDReader{}
	}
	return nil
}

func LogErr(err error) {
	if err != nil {
		fmt.Fprintf(os.Stderr, "%s\n", err)
	}
}

func main() {
	var path string
	var sourceType string
	var imgUrlExportFile string
	flag.StringVar(&path, "path", "", "path of the source files")
	flag.StringVar(&sourceType, "type", "", "type of the files (ACD, AniDB)")
	flag.StringVar(&imgUrlExportFile, "imageexportfile", "", "image URLs will be exported to this file, THIS WILL OVERWRITE EVERYTHING IN THE FILE!")
	flag.Parse()
	var exportFile *os.File
	if imgUrlExportFile != "" {
		var err error
		if exportFile, err = os.Create(imgUrlExportFile); err != nil {
			fmt.Fprintf(os.Stderr, "%s\n", "error while accessing \"%s\"")
			fmt.Fprintf(os.Stderr, "%v\n", err)
			os.Exit(1)
		}
	}
	if path == "" {
		fmt.Fprintf(os.Stderr, "%s\n", "\"path\" must be specified!")
		flag.Usage()
		os.Exit(1)
	}
	r := GetGrilReader(sourceType)
	if r == nil {
		fmt.Fprintf(os.Stderr, "%s\n", "\"type\" must be specified and a valid gril source!")
		flag.Usage()
		os.Exit(1)
	}
	config := grilist.LoadConfig()
	db, err := sql.Open("postgres", config.DBConnectionString())
	if err == nil {
		err = db.Ping()
	}
	if err != nil {
		fmt.Fprintf(os.Stderr, "%s\n", "error with database connection")
		fmt.Fprintf(os.Stderr, "%v\n", err)
		os.Exit(1)
	}
	taglist := make(map[string]int)
	rows, _ := db.Query("SELECT id, name FROM grilist.tags;")
	for rows.Next() {
		var id int
		var name string
		rows.Scan(&id)
		rows.Scan(&name)
		taglist[name] = id
	}
	idmap := make(map[int]int)
	rows, _ = db.Query("SELECT source_id, gril_id FROM grilist.grils_id_mappings WHERE source = $1;", r.ID())
	for rows.Next() {
		var sourceID int
		var grilID int
		rows.Scan(&sourceID)
		rows.Scan(&grilID)
		idmap[sourceID] = grilID
	}
	filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
		if info.IsDir() {
			return nil
		}
		g := r.Read(path)
		for _, v := range g.Gril.Tags {
			if _, ok := taglist[v]; ok {
				continue
			}
			var id int
			row := db.QueryRow("INSERT INTO grilist.tags (name) VALUES ($1) RETURNING id;", v)
			row.Scan(&id)
			taglist[v] = id
		}
		if _, ok := idmap[g.Gril.ID]; !ok {
			row := db.QueryRow("INSERT INTO grilist.grils (age) VALUES (NULL) RETURNING id;")
			var dbID int
			row.Scan(&dbID)
			for _, v := range g.Gril.Tags {
				tagID := taglist[v]
				db.Exec("INSERT INTO grilist.grils_tags (gril_id, tag_id) VALUES ($1, $2);", dbID, tagID)
			}
			db.Exec(`INSERT INTO grilist.grils_id_mappings (gril_id,
				source, source_id) VALUES ($1, $2, $3);`,
				dbID, r.ID(), g.Gril.ID)
			if g.Gril.KanjiName != "" {
				_, err := db.Exec(`INSERT INTO
				grilist.gril_names (gril_id, name, name_type)
				VALUES ($1, $2, $3);`, dbID, g.Gril.KanjiName,
					0)
				LogErr(err)
			}
			if g.Gril.RomajiName != "" {
				_, err := db.Exec(`INSERT INTO
				grilist.gril_names (gril_id, name, name_type)
				VALUES ($1, $2, $3);`, dbID, g.Gril.RomajiName,
					1)
				LogErr(err)
			}
			for _, v := range g.Gril.OtherNames {
				_, err := db.Exec(`INSERT INTO
				grilist.gril_names (gril_id, name, name_type)
				VALUES ($1, $2, $3);`, dbID, v, 2)
				LogErr(err)
			}
			if exportFile != nil {
				if g.Image != "" {
					fmt.Fprintf(
						exportFile,
						"%d %d %s\n",
						dbID,
						0,
						g.Image)
				}
				if g.Thumb != "" {
					fmt.Fprintf(
						exportFile,
						"%d %d %s\n",
						dbID,
						1,
						g.Thumb)
				}
			}
			fmt.Printf("Inserted %s\n", g.Gril.RomajiName)
		}
		return nil
	})
}