package hook

import (
	"seanime/internal/hook_resolver"
	"sort"
	"sync"

	"github.com/google/uuid"
	"github.com/rs/zerolog/log"
)

// Handler defines a single Hook handler.
// Multiple handlers can share the same id.
// If Id is not explicitly set it will be autogenerated by Hook.Add and Hook.AddHandler.
type Handler[T hook_resolver.Resolver] struct {
	// Func defines the handler function to execute.
	//
	// Note that users need to call e.Next() in order to proceed with
	// the execution of the hook chain.
	Func func(T) error

	// Id is the unique identifier of the handler.
	//
	// It could be used later to remove the handler from a hook via [Hook.Remove].
	//
	// If missing, an autogenerated value will be assigned when adding
	// the handler to a hook.
	Id string

	// Priority allows changing the default exec priority of the handler within a hook.
	//
	// If 0, the handler will be executed in the same order it was registered.
	Priority int
}

// Hook defines a generic concurrent safe structure for managing event hooks.
// When using custom event it must embed the base [hook.Event].
//
// Example:
//
//	type CustomEvent struct {
//		hook.Event
//		SomeField int
//	}
//
//	h := Hook[*CustomEvent]{}
//
//	h.BindFunc(func(e *CustomEvent) error {
//		println(e.SomeField)
//
//		return e.Next()
//	})
//
//	h.Trigger(&CustomEvent{ SomeField: 123 })
type Hook[T hook_resolver.Resolver] struct {
	handlers []*Handler[T]
	mu       sync.RWMutex
}

// Bind registers the provided handler to the current hooks queue.
//
// If handler.Id is empty it is updated with autogenerated value.
//
// If a handler from the current hook list has Id matching handler.Id
// then the old handler is replaced with the new one.
func (h *Hook[T]) Bind(handler *Handler[T]) string {
	if h == nil {
		return ""
	}
	h.mu.Lock()
	defer h.mu.Unlock()

	var exists bool

	if handler.Id == "" {
		handler.Id = generateHookId()

		// ensure that it doesn't exist
	DuplicateCheck:
		for _, existing := range h.handlers {
			if existing.Id == handler.Id {
				handler.Id = generateHookId()
				goto DuplicateCheck
			}
		}
	} else {
		// replace existing
		for i, existing := range h.handlers {
			if existing.Id == handler.Id {
				h.handlers[i] = handler
				exists = true
				break
			}
		}
	}

	// append new
	if !exists {
		h.handlers = append(h.handlers, handler)
	}

	// sort handlers by Priority, preserving the original order of equal items
	sort.SliceStable(h.handlers, func(i, j int) bool {
		return h.handlers[i].Priority < h.handlers[j].Priority
	})

	return handler.Id
}

// BindFunc is similar to Bind but registers a new handler from just the provided function.
//
// The registered handler is added with a default 0 priority and the id will be autogenerated.
//
// If you want to register a handler with custom priority or id use the [Hook.Bind] method.
func (h *Hook[T]) BindFunc(fn func(e T) error) string {
	return h.Bind(&Handler[T]{Func: fn})
}

// Unbind removes one or many hook handler by their id.
func (h *Hook[T]) Unbind(idsToRemove ...string) {
	if h == nil {
		return
	}
	h.mu.Lock()
	defer h.mu.Unlock()

	for _, id := range idsToRemove {
		for i := len(h.handlers) - 1; i >= 0; i-- {
			if h.handlers[i].Id == id {
				h.handlers = append(h.handlers[:i], h.handlers[i+1:]...)
				break // for now stop on the first occurrence since we don't allow handlers with duplicated ids
			}
		}
	}
}

// UnbindAll removes all registered handlers.
func (h *Hook[T]) UnbindAll() {
	if h == nil {
		return
	}
	h.mu.Lock()
	defer h.mu.Unlock()

	h.handlers = nil
}

// Length returns to total number of registered hook handlers.
func (h *Hook[T]) Length() int {
	if h == nil {
		return 0
	}
	h.mu.RLock()
	defer h.mu.RUnlock()

	return len(h.handlers)
}

// Trigger executes all registered hook handlers one by one
// with the specified event as an argument.
//
// Optionally, this method allows also to register additional one off
// handler funcs that will be temporary appended to the handlers queue.
//
// NB! Each hook handler must call event.Next() in order the hook chain to proceed.
func (h *Hook[T]) Trigger(event T, oneOffHandlerFuncs ...func(T) error) error {
	if h == nil {
		event.SetNextFunc(nil)
		return event.Next()
	}
	h.mu.RLock()
	handlers := make([]func(T) error, 0, len(h.handlers)+len(oneOffHandlerFuncs))
	for _, handler := range h.handlers {
		handlers = append(handlers, handler.Func)
	}
	handlers = append(handlers, oneOffHandlerFuncs...)
	h.mu.RUnlock()

	event.SetNextFunc(nil) // reset in case the event is being reused

	for i := len(handlers) - 1; i >= 0; i-- {
		i := i
		old := event.NextFunc()
		event.SetNextFunc(func() error {
			event.SetNextFunc(old)
			handlerErr := handlers[i](event)
			if handlerErr != nil {
				log.Error().Err(handlerErr).Msg("hook: Error in handler")
				return handlerErr
			}
			return nil
		})
	}

	return event.Next()
}

func generateHookId() string {
	return uuid.New().String()
}
