package component

import (
	"gitee.com/vibly/wechat-sdk/internal/util"
)

type InfoType string

const maxHandlerChainSize = 64

type HandlerChain []Handler

type Handler interface {
	ServeMsg(*Context)
}

// HandlerFunc =========================================================================================================

var _ Handler = HandlerFunc(nil)

type HandlerFunc func(*Context)

func (fn HandlerFunc) ServeMsg(ctx *Context) { fn(ctx) }

// ServeMux ============================================================================================================

var _ Handler = (*ServeMux)(nil)

//TODO:: 临时

// ServeMux 是一个消息(事件)路由器, 同时也是一个 Handler 的实现.
//  NOTE: ServeMux 非并发安全, 如果需要并发安全的 Handler, 可以参考 ServeMux 实现一个.
type ServeMux struct {
	startedChecker startedChecker

	//msgMiddlewares   HandlerChain
	infoMiddlewares HandlerChain

	//defaultMsgHandlerChain   HandlerChain
	defaultInfoHandlerChain HandlerChain

	//msgHandlerChainMap   map[MsgType]HandlerChain
	infoHandlerChainMap map[InfoType]HandlerChain
}

func NewServeMux() *ServeMux {
	return &ServeMux{
		//msgHandlerChainMap:   make(map[MsgType]HandlerChain),
		infoHandlerChainMap: make(map[InfoType]HandlerChain),
	}
}

var successResponseBytes = []byte("success")

// ServeMsg 实现 Handler 接口.
func (mux *ServeMux) ServeMsg(ctx *Context) {
	mux.startedChecker.start()
	if InfoType := ctx.InfoMsg.InfoType; InfoType != "" {
		handlers := mux.getInfoHandlerChain(InfoType)
		if len(handlers) == 0 {
			ctx.ResponseWriter.Write(successResponseBytes)
			return
		}
		ctx.handlers = handlers
		ctx.Next()
	}
	//} else if MsgType := ctx.MixedMsg.MsgType; MsgType != "event" {
	//	handlers := mux.getMsgHandlerChain(MsgType)
	//	if len(handlers) == 0 {
	//		ctx.ResponseWriter.Write(successResponseBytes)
	//		return
	//	}
	//	ctx.handlers = handlers
	//	ctx.Next()
	//} else {
	//	handlers := mux.getEventHandlerChain(ctx.MixedMsg.EventType)
	//	if len(handlers) == 0 {
	//		ctx.ResponseWriter.Write(successResponseBytes)
	//		return
	//	}
	//	ctx.handlers = handlers
	//	ctx.Next()
	//}
}

// getMsgHandlerChain 获取 HandlerChain 以处理消息类型为 MsgType 的消息, 如果没有找到返回 nil.
//func (mux *ServeMux) getMsgHandlerChain(msgType MsgType) (handlers HandlerChain) {
//	if m := mux.msgHandlerChainMap; len(m) > 0 {
//		handlers = m[MsgType(util.ToLower(string(msgType)))]
//		if len(handlers) == 0 {
//			handlers = mux.defaultMsgHandlerChain
//		}
//	} else {
//		handlers = mux.defaultMsgHandlerChain
//	}
//	return
//}

// getEventHandlerChain 获取 HandlerChain 以处理事件类型为 EventType 的事件, 如果没有找到返回 nil.
func (mux *ServeMux) getInfoHandlerChain(eventType InfoType) (handlers HandlerChain) {
	if m := mux.infoHandlerChainMap; len(m) > 0 {
		handlers = m[InfoType(util.ToLower(string(eventType)))]
		if len(handlers) == 0 {
			handlers = mux.defaultInfoHandlerChain
		}
	} else {
		handlers = mux.defaultInfoHandlerChain
	}
	return
}

// ServeMux: registers HandlerChain ====================================================================================

// Use 注册(新增) middlewares 使其在所有消息(事件)的 Handler 之前处理该处理消息(事件).
func (mux *ServeMux) Use(middlewares ...Handler) {
	mux.startedChecker.check()
	if len(middlewares) == 0 {
		return
	}
	for _, h := range middlewares {
		if h == nil {
			panic("handler can not be nil")
		}
	}
	//mux.useForMsg(middlewares)
	mux.useForInfo(middlewares)
}

// UseFunc 注册(新增) middlewares 使其在所有消息(事件)的 Handler 之前处理该处理消息(事件).
func (mux *ServeMux) UseFunc(middlewares ...func(*Context)) {
	mux.startedChecker.check()
	if len(middlewares) == 0 {
		return
	}
	for _, h := range middlewares {
		if h == nil {
			panic("handler can not be nil")
		}
	}
	middlewares2 := make(HandlerChain, len(middlewares))
	for i := 0; i < len(middlewares); i++ {
		middlewares2[i] = HandlerFunc(middlewares[i])
	}
	//mux.useForMsg(middlewares2)
	mux.useForInfo(middlewares2)
}

//
//// UseForMsg 注册(新增) middlewares 使其在所有消息的 Handler 之前处理该处理消息.
//func (mux *ServeMux) UseForMsg(middlewares ...Handler) {
//	mux.startedChecker.check()
//	if len(middlewares) == 0 {
//		return
//	}
//	for _, h := range middlewares {
//		if h == nil {
//			panic("handler can not be nil")
//		}
//	}
//	mux.useForMsg(middlewares)
//}
//
//// UseFuncForMsg 注册(新增) middlewares 使其在所有消息的 Handler 之前处理该处理消息.
//func (mux *ServeMux) UseFuncForMsg(middlewares ...func(*Context)) {
//	mux.startedChecker.check()
//	if len(middlewares) == 0 {
//		return
//	}
//	for _, h := range middlewares {
//		if h == nil {
//			panic("handler can not be nil")
//		}
//	}
//	middlewares2 := make(HandlerChain, len(middlewares))
//	for i := 0; i < len(middlewares); i++ {
//		middlewares2[i] = HandlerFunc(middlewares[i])
//	}
//	mux.useForMsg(middlewares2)
//}
//
//func (mux *ServeMux) useForMsg(middlewares []Handler) {
//	if len(mux.defaultMsgHandlerChain) > 0 || len(mux.msgHandlerChainMap) > 0 {
//		panic("please call this method before any other methods those registered handlers for message")
//	}
//	mux.msgMiddlewares = combineHandlerChain(mux.msgMiddlewares, middlewares)
//}

// UseForEvent 注册(新增) middlewares 使其在所有事件的 Handler 之前处理该处理事件.
func (mux *ServeMux) UseForInfo(middlewares ...Handler) {
	mux.startedChecker.check()
	if len(middlewares) == 0 {
		return
	}
	for _, h := range middlewares {
		if h == nil {
			panic("handler can not be nil")
		}
	}
	mux.useForInfo(middlewares)
}

// UseFuncForEvent 注册(新增) middlewares 使其在所有事件的 Handler 之前处理该处理事件.
func (mux *ServeMux) UseFuncForInfo(middlewares ...func(*Context)) {
	mux.startedChecker.check()
	if len(middlewares) == 0 {
		return
	}
	for _, h := range middlewares {
		if h == nil {
			panic("handler can not be nil")
		}
	}
	middlewares2 := make(HandlerChain, len(middlewares))
	for i := 0; i < len(middlewares); i++ {
		middlewares2[i] = HandlerFunc(middlewares[i])
	}
	mux.useForInfo(middlewares2)
}

func (mux *ServeMux) useForInfo(middlewares []Handler) {
	if len(mux.defaultInfoHandlerChain) > 0 || len(mux.infoHandlerChainMap) > 0 {
		panic("please call this method before any other methods those registered handlers for event")
	}
	mux.infoMiddlewares = combineHandlerChain(mux.infoMiddlewares, middlewares)
}

//
//// DefaultMsgHandle 设置 handlers 以处理没有匹配到具体类型的 HandlerChain 的消息.
//func (mux *ServeMux) DefaultMsgHandle(handlers ...Handler) {
//	mux.startedChecker.check()
//	if len(handlers) == 0 {
//		return
//	}
//	for _, h := range handlers {
//		if h == nil {
//			panic("handler can not be nil")
//		}
//	}
//	mux.defaultMsgHandlerChain = combineHandlerChain(mux.msgMiddlewares, handlers)
//}
//
//// DefaultMsgHandleFunc 设置 handlers 以处理没有匹配到具体类型的 HandlerChain 的消息.
//func (mux *ServeMux) DefaultMsgHandleFunc(handlers ...func(*Context)) {
//	mux.startedChecker.check()
//	if len(handlers) == 0 {
//		return
//	}
//	for _, h := range handlers {
//		if h == nil {
//			panic("handler can not be nil")
//		}
//	}
//	handlers2 := make(HandlerChain, len(handlers))
//	for i := 0; i < len(handlers); i++ {
//		handlers2[i] = HandlerFunc(handlers[i])
//	}
//	mux.defaultMsgHandlerChain = combineHandlerChain(mux.msgMiddlewares, handlers2)
//}

// DefaultEventHandle 设置 handlers 以处理没有匹配到具体类型的 HandlerChain 的事件.
func (mux *ServeMux) DefaultInfoHandle(handlers ...Handler) {
	mux.startedChecker.check()
	if len(handlers) == 0 {
		return
	}
	for _, h := range handlers {
		if h == nil {
			panic("handler can not be nil")
		}
	}
	mux.defaultInfoHandlerChain = combineHandlerChain(mux.infoMiddlewares, handlers)
}

// DefaultEventHandleFunc 设置 handlers 以处理没有匹配到具体类型的 HandlerChain 的事件.
func (mux *ServeMux) DefaultInfoHandleFunc(handlers ...func(*Context)) {
	mux.startedChecker.check()
	if len(handlers) == 0 {
		return
	}
	for _, h := range handlers {
		if h == nil {
			panic("handler can not be nil")
		}
	}
	handlers2 := make(HandlerChain, len(handlers))
	for i := 0; i < len(handlers); i++ {
		handlers2[i] = HandlerFunc(handlers[i])
	}
	mux.defaultInfoHandlerChain = combineHandlerChain(mux.infoMiddlewares, handlers2)
}

//
//// MsgHandle 设置 handlers 以处理特定类型的消息.
//func (mux *ServeMux) MsgHandle(msgType MsgType, handlers ...Handler) {
//	mux.startedChecker.check()
//	if len(handlers) == 0 {
//		return
//	}
//	for _, h := range handlers {
//		if h == nil {
//			panic("handler can not be nil")
//		}
//	}
//	mux.msgHandlerChainMap[MsgType(util.ToLower(string(msgType)))] = combineHandlerChain(mux.msgMiddlewares, handlers)
//}
//
//// MsgHandleFunc 设置 handlers 以处理特定类型的消息.
//func (mux *ServeMux) MsgHandleFunc(msgType MsgType, handlers ...func(*Context)) {
//	mux.startedChecker.check()
//	if len(handlers) == 0 {
//		return
//	}
//	for _, h := range handlers {
//		if h == nil {
//			panic("handler can not be nil")
//		}
//	}
//	handlers2 := make(HandlerChain, len(handlers))
//	for i := 0; i < len(handlers); i++ {
//		handlers2[i] = HandlerFunc(handlers[i])
//	}
//	mux.msgHandlerChainMap[MsgType(util.ToLower(string(msgType)))] = combineHandlerChain(mux.msgMiddlewares, handlers2)
//}

// EventHandle 设置 handlers 以处理特定类型的事件.
func (mux *ServeMux) InfoHandle(eventType InfoType, handlers ...Handler) {
	mux.startedChecker.check()
	if len(handlers) == 0 {
		return
	}
	for _, h := range handlers {
		if h == nil {
			panic("handler can not be nil")
		}
	}
	mux.infoHandlerChainMap[InfoType(util.ToLower(string(eventType)))] = combineHandlerChain(mux.infoMiddlewares, handlers)
}

// EventHandleFunc 设置 handlers 以处理特定类型的事件.
func (mux *ServeMux) InfoHandleFunc(eventType InfoType, handlers ...func(*Context)) {
	mux.startedChecker.check()
	if len(handlers) == 0 {
		return
	}
	for _, h := range handlers {
		if h == nil {
			panic("handler can not be nil")
		}
	}
	handlers2 := make(HandlerChain, len(handlers))
	for i := 0; i < len(handlers); i++ {
		handlers2[i] = HandlerFunc(handlers[i])
	}
	mux.infoHandlerChainMap[InfoType(util.ToLower(string(eventType)))] = combineHandlerChain(mux.infoMiddlewares, handlers2)
}

func combineHandlerChain(middlewares, handlers HandlerChain) HandlerChain {
	if len(middlewares)+len(handlers) > maxHandlerChainSize {
		panic("too many handlers")
	}
	return append(middlewares, handlers...)
}