package rui

import "strings"

const (
	// KeyDown is the constant for "key-down-event" property tag.
	// The "key-down-event" event is fired when a key is pressed.
	// The main listener format: func(View, KeyEvent).
	// The additional listener formats: func(KeyEvent), func(View), and func().
	KeyDownEvent = "key-down-event"

	// KeyPp is the constant for "key-up-event" property tag
	// The "key-up-event" event is fired when a key is released.
	// The main listener format: func(View, KeyEvent).
	// The additional listener formats: func(KeyEvent), func(View), and func().
	KeyUpEvent = "key-up-event"
)

type KeyEvent struct {
	// TimeStamp is the time at which the event was created (in milliseconds).
	// This value is time since epoch—but in reality, browsers' definitions vary.
	TimeStamp uint64

	// Key is the key value of the key represented by the event. If the value has a printed representation,
	// this attribute's value is the same as the char property. Otherwise, it's one of the key value strings
	// specified in Key values. If the key can't be identified, its value is the string "Unidentified".
	Key string

	// Code holds a string that identifies the physical key being pressed. The value is not affected
	// by the current keyboard layout or modifier state, so a particular key will always return the same value.
	Code string

	// Repeat == true if a key has been depressed long enough to trigger key repetition, otherwise false.
	Repeat bool

	// CtrlKey == true if the control key was down when the event was fired. false otherwise.
	CtrlKey bool

	// ShiftKey == true if the shift key was down when the event was fired. false otherwise.
	ShiftKey bool

	// AltKey == true if the alt key was down when the event was fired. false otherwise.
	AltKey bool

	// MetaKey == true if the meta key was down when the event was fired. false otherwise.
	MetaKey bool
}

func valueToKeyListeners(value interface{}) ([]func(View, KeyEvent), bool) {
	if value == nil {
		return nil, true
	}

	switch value := value.(type) {
	case func(View, KeyEvent):
		return []func(View, KeyEvent){value}, true

	case func(KeyEvent):
		fn := func(view View, event KeyEvent) {
			value(event)
		}
		return []func(View, KeyEvent){fn}, true

	case func(View):
		fn := func(view View, event KeyEvent) {
			value(view)
		}
		return []func(View, KeyEvent){fn}, true

	case func():
		fn := func(view View, event KeyEvent) {
			value()
		}
		return []func(View, KeyEvent){fn}, true

	case []func(View, KeyEvent):
		if len(value) == 0 {
			return nil, true
		}
		for _, fn := range value {
			if fn == nil {
				return nil, false
			}
		}
		return value, true

	case []func(KeyEvent):
		count := len(value)
		if count == 0 {
			return nil, true
		}
		listeners := make([]func(View, KeyEvent), count)
		for i, v := range value {
			if v == nil {
				return nil, false
			}
			listeners[i] = func(view View, event KeyEvent) {
				v(event)
			}
		}
		return listeners, true

	case []func(View):
		count := len(value)
		if count == 0 {
			return nil, true
		}
		listeners := make([]func(View, KeyEvent), count)
		for i, v := range value {
			if v == nil {
				return nil, false
			}
			listeners[i] = func(view View, event KeyEvent) {
				v(view)
			}
		}
		return listeners, true

	case []func():
		count := len(value)
		if count == 0 {
			return nil, true
		}
		listeners := make([]func(View, KeyEvent), count)
		for i, v := range value {
			if v == nil {
				return nil, false
			}
			listeners[i] = func(view View, event KeyEvent) {
				v()
			}
		}
		return listeners, true

	case []interface{}:
		count := len(value)
		if count == 0 {
			return nil, true
		}
		listeners := make([]func(View, KeyEvent), count)
		for i, v := range value {
			if v == nil {
				return nil, false
			}
			switch v := v.(type) {
			case func(View, KeyEvent):
				listeners[i] = v

			case func(KeyEvent):
				listeners[i] = func(view View, event KeyEvent) {
					v(event)
				}

			case func(View):
				listeners[i] = func(view View, event KeyEvent) {
					v(view)
				}

			case func():
				listeners[i] = func(view View, event KeyEvent) {
					v()
				}

			default:
				return nil, false
			}
		}
		return listeners, true
	}

	return nil, false
}

var keyEvents = map[string]struct{ jsEvent, jsFunc string }{
	KeyDownEvent: {jsEvent: "onkeydown", jsFunc: "keyDownEvent"},
	KeyUpEvent:   {jsEvent: "onkeyup", jsFunc: "keyUpEvent"},
}

func (view *viewData) setKeyListener(tag string, value interface{}) bool {
	listeners, ok := valueToKeyListeners(value)
	if !ok {
		notCompatibleType(tag, value)
		return false
	}

	if listeners == nil {
		view.removeKeyListener(tag)
	} else if js, ok := keyEvents[tag]; ok {
		view.properties[tag] = listeners
		if view.created {
			updateProperty(view.htmlID(), js.jsEvent, js.jsFunc+"(this, event)", view.Session())
		}
	} else {
		return false
	}
	return true
}

func (view *viewData) removeKeyListener(tag string) {
	delete(view.properties, tag)
	if view.created {
		if js, ok := keyEvents[tag]; ok {
			updateProperty(view.htmlID(), js.jsEvent, "", view.Session())
		}
	}
}

func getKeyListeners(view View, subviewID string, tag string) []func(View, KeyEvent) {
	if subviewID != "" {
		view = ViewByID(view, subviewID)
	}
	if view != nil {
		if value := view.Get(tag); value != nil {
			if result, ok := value.([]func(View, KeyEvent)); ok {
				return result
			}
		}
	}
	return []func(View, KeyEvent){}
}

func keyEventsHtml(view View, buffer *strings.Builder) {
	for tag, js := range keyEvents {
		if listeners := getKeyListeners(view, "", tag); len(listeners) > 0 {
			buffer.WriteString(js.jsEvent + `="` + js.jsFunc + `(this, event)" `)
		}
	}
}

func handleKeyEvents(view View, tag string, data DataObject) {
	listeners := getKeyListeners(view, "", tag)
	if len(listeners) == 0 {
		return
	}

	getBool := func(tag string) bool {
		if value, ok := data.PropertyValue(tag); ok && value == "1" {
			return true
		}
		return false
	}

	key, _ := data.PropertyValue("key")
	code, _ := data.PropertyValue("code")
	event := KeyEvent{
		TimeStamp: getTimeStamp(data),
		Key:       key,
		Code:      code,
		Repeat:    getBool("repeat"),
		CtrlKey:   getBool("ctrlKey"),
		ShiftKey:  getBool("shiftKey"),
		AltKey:    getBool("altKey"),
		MetaKey:   getBool("metaKey"),
	}

	for _, listener := range listeners {
		listener(view, event)
	}
}

// GetKeyDownListeners returns the "key-down-event" listener list. If there are no listeners then the empty list is returned.
// If the second argument (subviewID) is "" then a value from the first argument (view) is returned.
func GetKeyDownListeners(view View, subviewID string) []func(View, KeyEvent) {
	return getKeyListeners(view, subviewID, KeyDownEvent)
}

// GetKeyUpListeners returns the "key-up-event" listener list. If there are no listeners then the empty list is returned.
// If the second argument (subviewID) is "" then a value from the first argument (view) is returned.
func GetKeyUpListeners(view View, subviewID string) []func(View, KeyEvent) {
	return getKeyListeners(view, subviewID, KeyUpEvent)
}