package config

import (
	"strings"

	"github.com/gdamore/tcell/v2"
	"github.com/spf13/viper"
)

// NOTE: CmdLink[1-90] and CmdTab[1-90] need to be in-order and consecutive
// This property is used to simplify key handling in display/display.go
type Command int

const (
	CmdInvalid Command = 0
	CmdLink1           = 1
	CmdLink2           = 2
	CmdLink3           = 3
	CmdLink4           = 4
	CmdLink5           = 5
	CmdLink6           = 6
	CmdLink7           = 7
	CmdLink8           = 8
	CmdLink9           = 9
	CmdLink0           = 10
	CmdTab1            = 11
	CmdTab2            = 12
	CmdTab3            = 13
	CmdTab4            = 14
	CmdTab5            = 15
	CmdTab6            = 16
	CmdTab7            = 17
	CmdTab8            = 18
	CmdTab9            = 19
	CmdTab0            = 20
	CmdBottom          = iota
	CmdEdit
	CmdHome
	CmdBookmarks
	CmdAddBookmark
	CmdSave
	CmdReload
	CmdBack
	CmdForward
	CmdPgup
	CmdPgdn
	CmdNewTab
	CmdCloseTab
	CmdNextTab
	CmdPrevTab
	CmdQuit
	CmdHelp
	CmdSub
	CmdAddSub
)

type keyBinding struct {
	key tcell.Key
	mod tcell.ModMask
	r   rune
}

// Map of active keybindings to commands.
var bindings map[keyBinding]Command

// inversion of tcell.KeyNames, used to simplify config parsing.
// used by parseBinding() below.
var tcellKeys map[string]tcell.Key

// helper function that takes a single keyBinding object and returns
// a string in the format used by the configuration file.  Support
// function for GetKeyBinding(), used to make the help panel helpful.
func keyBindingToString(kb keyBinding) (string, bool) {
	var prefix string = ""

	if kb.mod&tcell.ModAlt == tcell.ModAlt {
		prefix = "Alt-"
	}

	if kb.key == tcell.KeyRune {
		if kb.r == ' ' {
			return prefix + "Space", true
		}
		return prefix + string(kb.r), true
	}
	s, ok := tcell.KeyNames[kb.key]
	if ok {
		return prefix + s, true
	}
	return "", false
}

// Get all keybindings for a Command as a string.
// Used by the help panel so bindable keys display with their
// bound values rather than hardcoded defaults.
func GetKeyBinding(cmd Command) string {
	var s string = ""
	for kb, c := range bindings {
		if c == cmd {
			t, ok := keyBindingToString(kb)
			if ok {
				s += t + ", "
			}
		}
	}

	if len(s) > 0 {
		return s[:len(s)-2]
	}
	return s
}

// Parse a single keybinding string and add it to the binding map
func parseBinding(cmd Command, binding string) {
	var k tcell.Key
	var m tcell.ModMask = 0
	var r rune = 0

	if strings.HasPrefix(binding, "Alt-") {
		m = tcell.ModAlt
		binding = binding[4:]
	}

	if len([]rune(binding)) == 1 {
		k = tcell.KeyRune
		r = []rune(binding)[0]
	} else if len(binding) == 0 {
		return
	} else if binding == "Space" {
		k = tcell.KeyRune
		r = ' '
	} else {
		var ok bool
		k, ok = tcellKeys[binding]
		if !ok { // Bad keybinding!  Quietly ignore...
			return
		}
		if strings.HasPrefix(binding, "Ctrl") {
			m += tcell.ModCtrl
		}
	}

	bindings[keyBinding{k, m, r}] = cmd
}

// Generate the bindings map from the TOML configuration file.
// Called by config.Init()
func KeyInit() {
	configBindings := map[Command]string{
		CmdLink1:       "keybindings.bind_link1",
		CmdLink2:       "keybindings.bind_link2",
		CmdLink3:       "keybindings.bind_link3",
		CmdLink4:       "keybindings.bind_link4",
		CmdLink5:       "keybindings.bind_link5",
		CmdLink6:       "keybindings.bind_link6",
		CmdLink7:       "keybindings.bind_link7",
		CmdLink8:       "keybindings.bind_link8",
		CmdLink9:       "keybindings.bind_link9",
		CmdLink0:       "keybindings.bind_link0",
		CmdBottom:      "keybindings.bind_bottom",
		CmdEdit:        "keybindings.bind_edit",
		CmdHome:        "keybindings.bind_home",
		CmdBookmarks:   "keybindings.bind_bookmarks",
		CmdAddBookmark: "keybindings.bind_add_bookmark",
		CmdSave:        "keybindings.bind_save",
		CmdReload:      "keybindings.bind_reload",
		CmdBack:        "keybindings.bind_back",
		CmdForward:     "keybindings.bind_forward",
		CmdPgup:        "keybindings.bind_pgup",
		CmdPgdn:        "keybindings.bind_pgdn",
		CmdNewTab:      "keybindings.bind_new_tab",
		CmdCloseTab:    "keybindings.bind_close_tab",
		CmdNextTab:     "keybindings.bind_next_tab",
		CmdPrevTab:     "keybindings.bind_prev_tab",
		CmdQuit:        "keybindings.bind_quit",
		CmdHelp:        "keybindings.bind_help",
		CmdSub:         "keybindings.bind_sub",
		CmdAddSub:      "keybindings.bind_add_sub",
	}
	// This is split off to allow shift_numbers to override bind_tab[1-90]
	// (This is needed for older configs so that the default bind_tab values
	// aren't used)
	configTabNBindings := map[Command]string{
		CmdTab1: "keybindings.bind_tab1",
		CmdTab2: "keybindings.bind_tab2",
		CmdTab3: "keybindings.bind_tab3",
		CmdTab4: "keybindings.bind_tab4",
		CmdTab5: "keybindings.bind_tab5",
		CmdTab6: "keybindings.bind_tab6",
		CmdTab7: "keybindings.bind_tab7",
		CmdTab8: "keybindings.bind_tab8",
		CmdTab9: "keybindings.bind_tab9",
		CmdTab0: "keybindings.bind_tab0",
	}
	tcellKeys = make(map[string]tcell.Key)
	bindings = make(map[keyBinding]Command)

	for k, kname := range tcell.KeyNames {
		tcellKeys[kname] = k
	}

	for c, allb := range configBindings {
		for _, b := range viper.GetStringSlice(allb) {
			parseBinding(c, b)
		}
	}

	// Backwards compatibility with the old shift_numbers config line.
	shiftNumbers := []rune(viper.GetString("keybindings.shift_numbers"))
	if len(shiftNumbers) > 0 && len(shiftNumbers) <= 10 {
		for i, r := range shiftNumbers {
			bindings[keyBinding{tcell.KeyRune, 0, r}] = CmdTab1 + Command(i)
		}
	} else {
		for c, allb := range configTabNBindings {
			for _, b := range viper.GetStringSlice(allb) {
				parseBinding(c, b)
			}
		}
	}
}

// Used by the display package to turn a tcell.EventKey into a Command
func TranslateKeyEvent(e *tcell.EventKey) Command {
	var ok bool
	var cmd Command
	k := e.Key()
	if k == tcell.KeyRune {
		cmd, ok = bindings[keyBinding{k, e.Modifiers(), e.Rune()}]
	} else { // Sometimes tcell sets e.Rune() on non-KeyRune events.
		cmd, ok = bindings[keyBinding{k, e.Modifiers(), 0}]
	}
	if ok {
		return cmd
	}
	return CmdInvalid
}