package main

import (
	"flag"
	"io/ioutil"
	"log"
	"os"
	"path"
	"path/filepath"
	"strconv"

	"gopkg.in/fsnotify.v1"
)

var (
	TeamsDir        string
	skipInitialSync bool
)

func main() {
	flag.StringVar(&TeamsDir, "teams", "./TEAMS", "Base directory where save teams JSON files")
	var debugINotify = flag.Bool("debuginotify", false, "Show skipped inotofy events")
	flag.BoolVar(&skipInitialSync, "skipinitialsync", skipInitialSync, "Skip the initial synchronization")
	daemon := flag.Bool("watch", false, "Enable daemon mode by watching the directory")
	tspath := flag.String("timestamp-file", "./REMOTE/timestamp", "Path to the file storing the last timestamp")
	exercicespath := flag.String("exercices-file", "./REMOTE/exercices-bindings.json", "Path to the file containing the ID bindings")
	coeff := flag.Float64("global-coeff", 10.0, "Coefficient to use to multiply all scores before passing them to the other platform")
	flag.Parse()

	api := AirbusAPI{
		BaseURL: "https://portal.european-cybercup.lan/api/v1",
	}

	if v, exists := os.LookupEnv("AIRBUS_BASEURL"); exists {
		api.BaseURL = v
	}
	if v, exists := os.LookupEnv("AIRBUS_TOKEN"); exists {
		api.Token = v
	}
	if v, exists := os.LookupEnv("AIRBUS_SESSIONID"); exists {
		var err error
		api.SessionID, err = strconv.ParseInt(v, 10, 64)
		if err != nil {
			log.Fatal("AIRBUS_SESSIONID is invalid: ", err.Error())
		}
	}

	log.SetPrefix("[challenge-sync-airbus] ")

	TeamsDir = path.Clean(TeamsDir)

	// Load the timestamp
	ts, err := loadTS(*tspath)
	if err != nil {
		log.Fatal("Unable to open timestamp file: ", err.Error())
	}

	// Load exercices bindings
	exbindings, err := ReadExercicesBindings(*exercicespath)
	if err != nil {
		log.Fatal("Unable to open exercices bindings file: ", err.Error())
	}

	// Load teams.json
	teamsbindings, err := getTeams(filepath.Join(TeamsDir, "teams.json"))
	if err != nil {
		log.Fatal("Unable to open teams bindings file: ", err.Error())
	}

	w := Walker{
		LastSync:  ts,
		Exercices: exbindings,
		Teams:     teamsbindings,
		API:       api,
		Coeff:     *coeff,
	}

	if !skipInitialSync {
		// Iterate over teams scores
		err = filepath.WalkDir(TeamsDir, w.WalkScore)
		if err != nil {
			log.Printf("Something goes wrong during walking")
		}

		// save current timestamp for teams
		err = saveTS(*tspath, w.LastSync)
		if err != nil {
			log.Fatal("Unable to save timestamp file: ", err.Error())
		}
	}

	if daemon != nil && *daemon {
		// Watch teams.json and scores.json
		log.Println("Registering directory events...")
		watcher, err := fsnotify.NewWatcher()
		if err != nil {
			log.Fatal(err)
		}
		defer watcher.Close()

		if err := watchsubdir(watcher, TeamsDir); err != nil {
			log.Fatal(err)
		}

		watchedNotify := fsnotify.Create

		for {
			select {
			case ev := <-watcher.Events:
				if d, err := os.Lstat(ev.Name); err == nil && ev.Op&fsnotify.Create == fsnotify.Create && d.Mode().IsDir() && d.Mode()&os.ModeSymlink == 0 && d.Name() != ".tmp" {
					// Register new subdirectory
					if err := watchsubdir(watcher, ev.Name); err != nil {
						log.Println(err)
					}
				} else if ev.Op&watchedNotify == watchedNotify && d.Mode().IsRegular() {
					if *debugINotify {
						log.Println("Treating event:", ev, "for", ev.Name)
					}
					if filepath.Base(ev.Name) == "scores.json" {
						go w.treat(ev.Name)
					} else if filepath.Base(ev.Name) == "teams.json" {
						teamsbindings, err := getTeams(filepath.Join(TeamsDir, "teams.json"))
						if err != nil {
							log.Println("Unable to open teams bindings file: ", err.Error())
							return
						}
						w.Teams = teamsbindings
					}
				} else if ev.Op&fsnotify.Write == fsnotify.Write {
					log.Println("FSNOTIFY WRITE SEEN. Prefer looking at them, as it appears files are not atomically moved.")
					watchedNotify = fsnotify.Write
				} else if *debugINotify {
					log.Println("Skipped event:", ev, "for", ev.Name)
				}
			case err := <-watcher.Errors:
				log.Println("error:", err)
			}
		}
	}
}

func watchsubdir(watcher *fsnotify.Watcher, pathname string) error {
	log.Println("Watch new directory:", pathname)
	if err := watcher.Add(pathname); err != nil {
		return err
	}

	if ds, err := ioutil.ReadDir(pathname); err != nil {
		return err
	} else {
		for _, d := range ds {
			p := path.Join(pathname, d.Name())
			if d.IsDir() && d.Name() != ".tmp" && d.Mode()&os.ModeSymlink == 0 {
				if err := watchsubdir(watcher, p); err != nil {
					return err
				}
			}
		}
		return nil
	}
}