package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"text/tabwriter"
	"unicode"
)

type App struct {
	Name      string            `json:"name"`
	Shortcuts map[string]string `json:"shortcuts"`
	HelpUrl   string            `json:"url"`
}

type Config struct {
	Apps []App `json:"apps"`
}

func getHomeDir() string {

	// get home directory
	home, err := os.UserHomeDir()
	if err != nil {
		panic(err)
	}
	return home
}

func getConfigScutDir() string {

	var configDir string

	// get home directory
	home := getHomeDir()
	homePathDir := home + "/.config/scut/config/"

	// get current directory of the binary
	ex, err := os.Executable()
	if err != nil {
		panic(err)
	}
	// get current directory of the binary without the binary name
	exePathDir := strings.TrimSuffix(ex, filepath.Base(ex))
	exePathDir = exePathDir + "config/"

	//if exePathDir existe alors on utilise le répertoire config du binaire
	if _, err := os.Stat(exePathDir); err == nil {
		configDir = exePathDir

		//si non si homePathDir existe alors on utilise le répertoire config du home
	} else if _, err := os.Stat(homePathDir); err == nil {

		configDir = homePathDir
		//si non on utilise le répertoire config du binaire
	} else {
		configDir = ""
	}

	return configDir
}

func loadConfig(dir string) Config {
	apps := []App{}

	// Ouvre le répertoire config
	files, err := ioutil.ReadDir(dir)
	if err != nil {
		//panic(err)
		fmt.Println("Le répertoire config est inexistant !")
		os.Exit(1)
	}

	// Lis tous les fichiers .json
	for _, file := range files {
		if filepath.Ext(file.Name()) == ".json" {
			data, _ := ioutil.ReadFile(dir + "/" + file.Name())

			var app App
			json.Unmarshal(data, &app)
			apps = append(apps, app)
		}
	}
	config := Config{
		Apps: apps,
	}

	return config
}

// sort shortcuts by name
func sortShortcuts(shortcuts map[string]string) map[string]string {

	// Create a slice of keys
	keys := make([]string, 0, len(shortcuts))

	// Append the keys from the map to the slice
	for k := range shortcuts {
		keys = append(keys, k)
	}

	// Sort the slice of keys
	//sort.Strings(keys)

	// Create a new map to store the sorted keys
	sortedShortcuts := make(map[string]string)

	// Iterate over the slice of keys
	for _, k := range keys {
		sortedShortcuts[k] = shortcuts[k]
	}

	return sortedShortcuts
}

func main() {

	underline := "- -- - -- - -- - -- - -- - -- - -- - -- - -- - --"

	flag.Usage = func() {
		fmt.Println("")
		fmt.Println(underline)
		fmt.Println("  Scut-Reminder : Gestion des raccourcis")
		fmt.Println(underline)
		fmt.Println("\n     Options :")
		fmt.Println(underline)
		fmt.Printf(" -c PathDuDossierConfig     	|| Path du dossier de configuration au lieu du répertoire ./config (par défaut)\n")
		fmt.Printf(" -a Nom Application        	|| Afficher les raccourcis de l'application spécifiée\n")
		fmt.Printf(" -f fitre        		|| Filtrer les raccourcis qui contiennent le filtre\n")
		fmt.Printf(" -u                        	|| Afficher les URLs des raccourcis de chaque applications\n")
		fmt.Printf(" -h                        	|| Afficher cette aide\n")
		fmt.Println("")
		fmt.Println("     Example :")
		fmt.Println(underline)
		fmt.Printf(" scut				  || Affiche la liste des applications\n\n")
		fmt.Printf(" scut -c MaConfig.json -a \"nevim\" || Affiche liste des raccourcis de nevim de MaConfig.json \n\n")
		fmt.Printf(" scut -a \"Visual Studio Code\" 	  || Affiche liste des raccourcis de vscode \n\n")
		fmt.Printf(" scut -a \"Kitty\" -f quit 	  || Affiche liste des raccourcis qui contient 'quit' \n\n")
		fmt.Println("")
	}

	configDir := flag.String("c", getConfigScutDir(), "Config directory")

	appName := flag.String("a", "", "Application name")

	filter := flag.String("f", "", "Filter")

	urls := flag.Bool("u", false, "Afficher les URLs d'aide des raccourcis de chaque applications")

	flag.Parse()

	config := loadConfig(*configDir)

	cleanFilter := strings.TrimFunc(*filter, func(r rune) bool {
		return !unicode.IsGraphic(r)
	})

	if *urls == true {
		w := tabwriter.NewWriter(os.Stdout, 0, 0, 10, '.', 0)
		fmt.Println(underline)
		fmt.Println("          U R L S")
		fmt.Println(underline)
		for _, app := range config.Apps {

			// fmt.Printf("%s %s\n", app.Name, app.HelpUrl)
			fmt.Fprintf(w, "%s \t %s\n", app.Name, app.HelpUrl)

		}
		w.Flush()

	} else if *appName == "" {

		// List all applications
		fmt.Println(underline)
		fmt.Println("          A P P L I C A T I O N S")
		fmt.Println(underline)
		for _, app := range config.Apps {
			fmt.Printf("%s\n", app.Name)
		}
		fmt.Println()

	} else {
		w := tabwriter.NewWriter(os.Stdout, 0, 0, 10, '.', 0)
		if *filter != "" {
			for _, app := range config.Apps {
				if strings.ToUpper(app.Name) == strings.ToUpper(*appName) {
					fmt.Println(underline)
					fmt.Fprintln(w, "          S H O R T C U T S : "+app.Name)
					fmt.Println(underline)
					for shortcut, desc := range sortShortcuts(app.Shortcuts) {
						if strings.Contains(strings.ToUpper(shortcut), strings.ToUpper(cleanFilter)) || strings.Contains(strings.ToUpper(desc), strings.ToUpper(cleanFilter)) {
							fmt.Fprintf(w, "%s \t %s\n", shortcut, desc)
						}
					}
				}
			}
			w.Flush()
		} else {
			for _, app := range config.Apps {
				if strings.ToUpper(app.Name) == strings.ToUpper(*appName) {
					fmt.Println(underline)
					fmt.Fprintln(w, "          S H O R T C U T S : "+app.Name)
					fmt.Println(underline)
					for shortcut, desc := range app.Shortcuts {
						fmt.Fprintf(w, "%s \t %s\n", shortcut, desc)
					}
				}
			}
			w.Flush()
		}
	}

}