package components

import (
	"fmt"
	"net"
	"pro2d/common/logger"
)

type ServerOption func(*Server)

func WithPlugin(iPlugin IPlugin) ServerOption {
	return func(server *Server) {
		server.plugins = iPlugin
	}
}

func WithSplitter(splitter ISplitter) ServerOption {
	return func(server *Server) {
		server.splitter = splitter
	}
}

func WithConnCbk(cb ConnectionCallback) ServerOption {
	return func(server *Server) {
		server.connectionCallback = cb
	}
}

func WithMsgCbk(cb MessageCallback) ServerOption {
	return func(server *Server) {
		server.messageCallback = cb
	}
}

func WithCloseCbk(cb CloseCallback) ServerOption {
	return func(server *Server) {
		server.closeCallback = cb
	}
}

func WithTimerCbk(cb TimerCallback) ServerOption {
	return func(server *Server) {
		server.timerCallback = cb
	}
}

type Server struct {
	PluginPath string
	plugins    IPlugin
	splitter   ISplitter

	connectionCallback ConnectionCallback
	messageCallback    MessageCallback
	closeCallback      CloseCallback
	timerCallback      TimerCallback

	port       int
	connManage *ConnManage
}

func NewServer(port int, options ...ServerOption) IServer {
	s := &Server{
		port:       port,
		connManage: NewConnManage(),
	}
	for _, option := range options {
		option(s)
	}

	return s
}

func (s *Server) GetSplitter() ISplitter {
	return s.splitter
}

func (s *Server) GetPlugin() IPlugin {
	return s.plugins
}

func (s *Server) GetAction(cmd uint32) interface{} {
	return s.plugins.GetAction(cmd)
}

func (s *Server) GetConnManage() IConnManage {
	return s.connManage
}

func (s *Server) SetConnectionCallback(cb ConnectionCallback) {
	s.connectionCallback = cb
}

func (s *Server) SetMessageCallback(cb MessageCallback) {
	s.messageCallback = cb
}

func (s *Server) SetCloseCallback(cb CloseCallback) {
	s.closeCallback = cb
}

func (s *Server) SetTimerCallback(cb TimerCallback) {
	s.timerCallback = cb
}

func (s *Server) Start() error {
	if err := s.plugins.LoadPlugin(); err != nil {
		return err
	}

	port := fmt.Sprintf(":%d", s.port)
	l, err := net.Listen("tcp", port)
	if err != nil {
		return err
	}
	//监听端口
	logger.Debug("listen on %s\n", port)
	id := 0
	for {
		conn, err := l.Accept()
		if err != nil {
			return err
		}

		id++
		client := NewConn(id, conn, s)
		s.newConnection(client)
	}
}

func (s *Server) Stop() {
	StopTimer()

}

func (s *Server) newConnection(conn IConnection) {
	conn.SetConnectionCallback(s.connectionCallback)
	conn.SetCloseCallback(s.removeConnection)
	conn.SetMessageCallback(s.messageCallback)
	conn.SetTimerCallback(s.timerCallback)

	go conn.Start()
}

func (s *Server) removeConnection(conn IConnection) {
	s.closeCallback(conn)
}