package main

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

	clir "github.com/deranjer/clir"
	clientcmd "github.com/deranjer/gvc/client/clientcmd"
	clientconfig "github.com/deranjer/gvc/client/clientconfig"
	config "github.com/deranjer/gvc/client/clientconfig"
	"github.com/deranjer/store"
)

var version = "0.1.5"
var configPath = ".gvc" + string(filepath.Separator) + ".gvcconfig.toml"
var rootPath string

func main() {
	// Sloppily inject a global variable //TODO maybe just path the variables manually or create a struct with them all in
	injectVariables()

	// Getting the root path
	var err error
	rootPath, err = os.Getwd()
	if err != nil {
		log.Fatalf("Can't get working dir, permissions issue? %s", err)
	}

	// Setting up a blank config to read the .toml file in if one exists
	var conf clientconfig.Gvcconfig
	isRepo := validateRepo()
	if isRepo {
		err := store.Load(configPath, &conf)
		if err != nil {
			fmt.Printf("Error loading config file into struct, please fix config, panic! \n%s", err)
			os.Exit(0)
		}
		err = clientconfig.ValidateConfig(&conf, version)
		if err != nil {
			fmt.Println("Error validating config, your config file is corrupt! ", err)
			os.Exit(0)
		}
	}
	// Initialize our new cli
	cli := clir.NewCli("gvcc", "Version control client for GVC", version)

	// Adding the init command
	initCommand(cli, &conf)

	// Adding all the "add" commands
	addCommands(cli, &conf)

	// Adding the ignore commands
	ignoreCommands(cli, &conf)

	// Adding the test commands
	infoCommands(cli, &conf)

	// Adding the refresh command
	refreshCommand(cli, &conf)

	// Adding the "remote" commands
	remoteCommands(cli, &conf)

	err = cli.Run()
	if err != nil {
		fmt.Printf("Error occurred: %v\n", err)
	}
	err = store.Save(configPath, conf)
	if err != nil {
		fmt.Println("Error saving config to file, changes were not writted! Check config file... ", err)
	}
}

// injectVariables just injects the global variables into the packages
func injectVariables() {
	clientcmd.ConfigPath = configPath
	config.ConfigPath = configPath
}

// validateRepo just ensures that the command is being run against an actual repo (bool yes or no)
func validateRepo() bool {
	if _, err := os.Stat(configPath); os.IsNotExist(err) {
		return false
	}
	return true
}

// refreshCommand contacts the server and pulls down locked files/commits/etc to the client (like git fetch)
func refreshCommand(cli *clir.Cli, conf *clientconfig.Gvcconfig) {
	refreshCmd := cli.NewSubCommand("refresh", "pulls down all locks/branches/commits unknown to client")
	refreshCmd.LongDescription("Works similar to git fetch where it shows the number of commits pushed to server/branches that the client doesn't know as well as file/folder locks")
	refreshCmd.Action(func() error {
		isRepo := validateRepo()
		if !isRepo {
			fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
			os.Exit(0)
		}
		err := clientcmd.RefreshContent(conf)
		if err != nil {
			return fmt.Errorf("unable to refresh content: %s", err)
		}
		return nil
	})
}

func initCommand(cli *clir.Cli, conf *clientconfig.Gvcconfig) {
	//The init subcommand
	initCmd := cli.NewSubCommand("init", "initializes a new gvc repo")
	initCmd.LongDescription("This will create the .gvcconfig.toml (with defaults) file in this directory. You can edit this file directly (unsafe) or with the client(safe)")
	initCmd.Action(func() error {
		isRepo := validateRepo()
		if !isRepo {
			clientcmd.InitializeRepo() // creates and checks the paths
			newConf := clientconfig.Gvcconfig{
				Version:       version,
				CurrentBranch: "master",
			}
			err := store.Save(configPath, &newConf)
			if err != nil {
				log.Fatalf("unable to create new config in .gvc %s", err)
			}
			return nil
		}
		fmt.Println("appears that this directory is already a gvc repo")
		return nil
	})
}

func addCommands(cli *clir.Cli, conf *clientconfig.Gvcconfig) {
	//All the add commands and subcommands
	//The add subcommand
	addCmd := cli.NewSubCommand("add", "adds file(s)/folder(s) (recursively for folder) to repo")
	addCmd.LongDescription("You can add all: all, a -file (-f): file.txt, or a -folder (-fd): folder, or a -wildcard (-wc): *.txt")
	//File/Folder/Wildcard adding
	var file string
	var folder string
	var wildcard string
	fileFlag := addCmd.StringFlag("file", "tracks a file to add to the repo", &file)
	fileFlag.FlagShortCut("file", "f")
	folderFlag := addCmd.StringFlag("folder", "tracks all contents of a folder to add to the repo", &folder)
	folderFlag.FlagShortCut("folder", "fd")
	wildCardFlag := addCmd.StringFlag("wildcard", "treats the input as a wildcard and tracks all files that match the wildcard", &wildcard)
	wildCardFlag.FlagShortCut("wildcard", "wc")
	addCmd.Action(func() error {
		isRepo := validateRepo()
		if !isRepo {
			fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
			os.Exit(0)
		}
		if len(addCmd.OtherArgs()) > 0 {
			addCmd.PrintHelp()
			return fmt.Errorf("incorrect input detected, please fix and retry")
		}
		if file != "" { // if the file flag was used it won't be empty
			fmt.Println("adding file to tracked files: ", file)
			err := clientcmd.AddFiles(file, "file", conf.Ignores)
			if err != nil {
				return err
			}
			return nil
		}
		if folder != "" { // if the folder flag was used it won't be empty
			fmt.Println("adding contents of folder to tracked files: ", folder)
			err := clientcmd.AddFiles(folder, "folder", conf.Ignores)
			if err != nil {
				return err
			}
			return nil
		}
		if wildcard != "" { // if the wildcard flag was used it won't be empty
			fmt.Println("adding files with wildcard filter: ", wildcard)
			err := clientcmd.AddFiles(wildcard, "wildcard", conf.Ignores)
			if err != nil {
				return err
			}
			return nil
		}
		return nil
	})

	//Add all files recursively to repo
	addall := addCmd.NewSubCommand("all", "add all of the file(s)/folders(s) in root dir recursively to repo")
	addall.Action(func() error {
		isRepo := validateRepo()
		if !isRepo {
			fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
			os.Exit(0)
		}
		if len(addall.OtherArgs()) > 0 {
			addCmd.PrintHelp()
			return fmt.Errorf("the 'all' subcommand does not accept additional arguments")
		}
		fmt.Println("adding all files recursively in directory to tracked files")
		err := clientcmd.AddFiles("", "all", conf.Ignores)
		if err != nil {
			return err
		}
		return nil
	})
}

func ignoreCommands(cli *clir.Cli, conf *clientconfig.Gvcconfig) {
	//All the ignore commands and subcommands
	//The ignore subcommand
	ignoreCmd := cli.NewSubCommand("ignore", "ignores file(s)/folder(s) (recursively for folder) to repo")
	ignoreCmd.LongDescription("You can ignore all: all, a -file (-f): file.txt, or a -folder (-fd): folder, or a -wildcard (-wc): *.txt")
	//File/Folder/Wildcard Ignoring
	var file string
	var folder string
	var wildcard string
	fileFlag := ignoreCmd.StringFlag("file", "adds a file to ignore to the config", &file)
	fileFlag.FlagShortCut("file", "f")
	folderFlag := ignoreCmd.StringFlag("folder", "tracks all contents of a folder to ignore", &folder)
	folderFlag.FlagShortCut("folder", "fd")
	wildCardFlag := ignoreCmd.StringFlag("wildcard", "treats the input as a wildcard and ignores all files that match the wildcard", &wildcard)
	wildCardFlag.FlagShortCut("wildcard", "wc")
	ignoreCmd.Action(func() error {
		isRepo := validateRepo()
		if !isRepo {
			fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
			os.Exit(0)
		}
		if len(ignoreCmd.OtherArgs()) > 0 {
			ignoreCmd.PrintHelp()
			return fmt.Errorf("incorrect input detected, please fix and retry")
		}
		if file != "" { // if the file flag was used it won't be empty
			//fmt.Println("Ignoring file: ", file)
			err := clientcmd.IgnoreFiles(file, "file", conf)
			if err != nil {
				return err
			}
			return nil
		}
		if folder != "" { // if the folder flag was used it won't be empty
			fmt.Println("Ignoring contents of folder: ", folder)
			err := clientcmd.IgnoreFiles(folder, "folder", conf)
			if err != nil {
				return err
			}
			return nil
		}
		if wildcard != "" { // if the wildcard flag was used it won't be empty
			fmt.Println("Ignoring files with wildcard filter: ", wildcard)
			err := clientcmd.IgnoreFiles(wildcard, "wildcard", conf)
			if err != nil {
				return err
			}
			return nil
		}
		return nil
	})
	// Adding the remove ignore command (remove from the ignore list)
	removeIgnoreCmd(ignoreCmd, conf)

}

// removeIgnoreCmd removes files/folders/wildcard from the ignore list
func removeIgnoreCmd(ignoreCmd *clir.Command, conf *clientconfig.Gvcconfig) {
	removeIgnoreCmd := ignoreCmd.NewSubCommand("remove", "remove from ignores file(s)/folder(s) (recursively for folder) to repo")
	removeIgnoreCmd.LongDescription("You can remove from ignore all: all, a -file (-f): file.txt, or a -folder (-fd): folder, or a -wildcard (-wc): *.txt")
	//File/Folder/Wildcard Ignoring
	var file string
	var folder string
	var wildcard string
	fileFlag := removeIgnoreCmd.StringFlag("file", "removes ignored file from config", &file)
	fileFlag.FlagShortCut("file", "f")
	folderFlag := removeIgnoreCmd.StringFlag("folder", "removes ignored folder", &folder)
	folderFlag.FlagShortCut("folder", "fd")
	wildCardFlag := removeIgnoreCmd.StringFlag("wildcard", "removes wildcard from ignores", &wildcard)
	wildCardFlag.FlagShortCut("wildcard", "wc")
	removeIgnoreCmd.Action(func() error {
		isRepo := validateRepo()
		if !isRepo {
			fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
			os.Exit(0)
		}
		if len(removeIgnoreCmd.OtherArgs()) > 0 {
			removeIgnoreCmd.PrintHelp()
			return fmt.Errorf("incorrect input detected, please fix and retry")
		}
		if file != "" { // if the file flag was used it won't be empty
			//fmt.Println("Ignoring file: ", file)
			err := clientcmd.RemoveIgnoreFiles(file, "file", conf)
			if err != nil {
				return err
			}
			return nil
		}
		if folder != "" { // if the folder flag was used it won't be empty
			fmt.Println("Ignoring contents of folder: ", folder)
			err := clientcmd.RemoveIgnoreFiles(folder, "folder", conf)
			if err != nil {
				return err
			}
			return nil
		}
		if wildcard != "" { // if the wildcard flag was used it won't be empty
			fmt.Println("Ignoring files with wildcard filter: ", wildcard)
			err := clientcmd.RemoveIgnoreFiles(wildcard, "wildcard", conf)
			if err != nil {
				return err
			}
			return nil
		}
		return nil
	})
}

func infoCommands(cli *clir.Cli, conf *clientconfig.Gvcconfig) {
	//All the info commands
	infoCmd := cli.NewSubCommand("info", "tests various aspects of the client/files/etc and server")
	infoCmd.LongDescription("You can get information on remotes, files, etc")

	remoteInfoCmd := infoCmd.NewSubCommand("remote", "takes the suppled server name and gets information about the server")
	remoteInfoCmd.Action(func() error {
		isRepo := validateRepo()
		if !isRepo {
			fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
			os.Exit(0)
		}
		if len(remoteInfoCmd.OtherArgs()) == 0 {
			remoteInfoCmd.PrintHelp()
			return fmt.Errorf("Please supply a server name to test a remote")
		}
		server := remoteInfoCmd.OtherArgs()[0]
		conn, err := clientcmd.ConnectToServer(server, "master", conf)
		if err != nil {
			return err
		}
		err = clientcmd.GetServerInfo(conn)
		if err != nil {
			return err
		}
		return nil
	})
	// 	//File/Folder/Wildcard Ignoring
	// 	var file string
	// 	var folder string
	// 	var wildcard string
	// 	fileFlag := ignoreCmd.StringFlag("file", "adds a file to ignore to the config", &file)
	// 	fileFlag.FlagShortCut("file", "f")
	// 	folderFlag := ignoreCmd.StringFlag("folder", "tracks all contents of a folder to ignore", &folder)
	// 	folderFlag.FlagShortCut("folder", "fd")
	// 	wildCardFlag := ignoreCmd.StringFlag("wildcard", "treats the input as a wildcard and ignores all files that match the wildcard", &wildcard)
	// 	wildCardFlag.FlagShortCut("wildcard", "wc")
	// 	ignoreCmd.Action(func() error {
	// 		isRepo := validateRepo()
	// 		if !isRepo {
	// 			fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
	// 			os.Exit(0)
	// 		}
	// 		if len(ignoreCmd.OtherArgs()) > 0 {
	// 			ignoreCmd.PrintHelp()
	// 			return fmt.Errorf("incorrect input detected, please fix and retry")
	// 		}
	// 		if file != "" { // if the file flag was used it won't be empty
	// 			//fmt.Println("Ignoring file: ", file)
	// 			err := clientcmd.IgnoreFiles(file, "file", conf)
	// 			if err != nil {
	// 				return err
	// 			}
	// 			return nil
	// 		}
	// 		if folder != "" { // if the folder flag was used it won't be empty
	// 			fmt.Println("Ignoring contents of folder: ", folder)
	// 			err := clientcmd.IgnoreFiles(folder, "folder", conf)
	// 			if err != nil {
	// 				return err
	// 			}
	// 			return nil
	// 		}
	// 		if wildcard != "" { // if the wildcard flag was used it won't be empty
	// 			fmt.Println("Ignoring files with wildcard filter: ", wildcard)
	// 			err := clientcmd.IgnoreFiles(wildcard, "wildcard", conf)
	// 			if err != nil {
	// 				return err
	// 			}
	// 			return nil
	// 		}
	// 		return nil
	// 	})
}

func remoteCommands(cli *clir.Cli, conf *config.Gvcconfig) {
	//The add remote command
	remoteCmd := cli.NewSubCommand("remote", "add/delete/show remotes")
	var name string
	var host string
	var port int
	var defaultRemote bool
	remoteAddCmd := remoteCmd.NewSubCommand("add", "add a remote, requires -name -host and -port")
	remoteAddCmd.LongDescription("Adds a remote to the .gvcconfig.toml.  Requires the -name, -host and -port flags. Example: gvc remote add -name exampleRemote -host examplehost.com -port 8080")
	nameFlag := remoteAddCmd.StringFlag("name", "the name you want for your remote server", &name)
	nameFlag.FlagShortCut("name", "n")
	remoteAddCmd.FlagRequired("name")
	hostFlag := remoteAddCmd.StringFlag("host", "the hostname or IP Address of the remote", &host)
	hostFlag.FlagShortCut("host", "h")
	remoteAddCmd.FlagRequired("host")
	portFlag := remoteAddCmd.IntFlag("port", "the port the remote server is listening on", &port)
	portFlag.FlagShortCut("port", "p")
	remoteAddCmd.FlagRequired("port")
	defaultFlag := remoteAddCmd.BoolFlag("default", "is used, the repo is set as default. (if first remote automatically set as default)", &defaultRemote)
	defaultFlag.FlagShortCut("default", "d")
	remoteAddCmd.Action(func() error {
		isRepo := validateRepo()
		if !isRepo {
			fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
			os.Exit(0)
		}
		if name == "" || host == "" || port == 0 || port == 1 || port > 65535 {
			fmt.Println("incorrect input found, exiting, ensure you entered a valid port")
			os.Exit(0)
		}
		newRemotes, err := clientcmd.AddRemote(name, host, port, defaultRemote, conf.Remotes)
		conf.Remotes = newRemotes //Overwriting the old Remote list with new list
		if err != nil {
			return fmt.Errorf("error adding remote: %s", err)
		}
		return nil
	})
}

func lockCommands(cli clir.Cli, conf *clientconfig.Gvcconfig) {

	//All the lock commands and subcommands
	//The lock subcommand
	lockCmd := cli.NewSubCommand("lock", "locks file(s)/folder(s) (recursively for folder) to repo")
	lockCmd.LongDescription("You can lock all: all, a -file (-f): file.txt, or a -folder (-fd): folder, or a -wildcard (-wc): *.txt")
	//File/Folder/Wildcard Ignoring
	var file string
	var folder string
	var wildcard string
	fileFlag := lockCmd.StringFlag("file", "adds a file to lock to the config", &file)
	fileFlag.FlagShortCut("file", "f")
	folderFlag := lockCmd.StringFlag("folder", "tracks all contents of a folder to lock", &folder)
	folderFlag.FlagShortCut("folder", "fd")
	wildCardFlag := lockCmd.StringFlag("wildcard", "treats the input as a wildcard and locks all files that match the wildcard", &wildcard)
	wildCardFlag.FlagShortCut("wildcard", "wc")
	lockCmd.Action(func() error {
		isRepo := validateRepo()
		if !isRepo {
			fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
			os.Exit(0)
		}
		if len(lockCmd.OtherArgs()) > 0 {
			lockCmd.PrintHelp()
			return fmt.Errorf("incorrect input detected, please fix and retry")
		}
		if file != "" { // if the file flag was used it won't be empty
			//fmt.Println("Ignoring file: ", file)
			err := clientcmd.LockFiles(file, "file", conf)
			if err != nil {
				return err
			}
			return nil
		}
		if folder != "" { // if the folder flag was used it won't be empty
			fmt.Println("Ignoring contents of folder: ", folder)
			err := clientcmd.LockFiles(folder, "folder", conf)
			if err != nil {
				return err
			}
			return nil
		}
		if wildcard != "" { // if the wildcard flag was used it won't be empty
			fmt.Println("Ignoring files with wildcard filter: ", wildcard)
			err := clientcmd.LockFiles(wildcard, "wildcard", conf)
			if err != nil {
				return err
			}
			return nil
		}
		return nil
	})
	// Adding the remove lock command (remove from the lock list)
	removeLockCmd(lockCmd, conf)
}

// removeLockCmd removes files/folders/wildcard from the ignore list
func removeLockCmd(ignoreCmd *clir.Command, conf *clientconfig.Gvcconfig) {
	RemoveLockCmd := ignoreCmd.NewSubCommand("remove", "remove from ignores file(s)/folder(s) (recursively for folder) to repo")
	RemoveLockCmd.LongDescription("You can remove from ignore all: all, a -file (-f): file.txt, or a -folder (-fd): folder, or a -wildcard (-wc): *.txt")
	//File/Folder/Wildcard Ignoring
	var file string
	var folder string
	var wildcard string
	fileFlag := RemoveLockCmd.StringFlag("file", "removes ignored file from config", &file)
	fileFlag.FlagShortCut("file", "f")
	folderFlag := RemoveLockCmd.StringFlag("folder", "removes ignored folder", &folder)
	folderFlag.FlagShortCut("folder", "fd")
	wildCardFlag := RemoveLockCmd.StringFlag("wildcard", "removes wildcard from ignores", &wildcard)
	wildCardFlag.FlagShortCut("wildcard", "wc")
	RemoveLockCmd.Action(func() error {
		isRepo := validateRepo()
		if !isRepo {
			fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
			os.Exit(0)
		}
		if len(RemoveLockCmd.OtherArgs()) > 0 {
			RemoveLockCmd.PrintHelp()
			return fmt.Errorf("incorrect input detected, please fix and retry")
		}
		if file != "" { // if the file flag was used it won't be empty
			//fmt.Println("Ignoring file: ", file)
			err := clientcmd.RemoveLockFiles(file, "file", conf)
			if err != nil {
				return err
			}
			return nil
		}
		if folder != "" { // if the folder flag was used it won't be empty
			fmt.Println("Ignoring contents of folder: ", folder)
			err := clientcmd.RemoveLockFiles(folder, "folder", conf)
			if err != nil {
				return err
			}
			return nil
		}
		if wildcard != "" { // if the wildcard flag was used it won't be empty
			fmt.Println("Ignoring files with wildcard filter: ", wildcard)
			err := clientcmd.RemoveLockFiles(wildcard, "wildcard", conf)
			if err != nil {
				return err
			}
			return nil
		}
		return nil
	})
}