package components

import (
	"fmt"
	"github.com/golang/protobuf/proto"
	"net"
	"plugin"
	"pro2d/pb"
	"pro2d/utils/logger"
	"sync"
)

type ActionHandler func (msg IMessage)  (int32, proto.Message)
var ActionMap map[pb.ProtoCode]ActionHandler

type Server struct {
	IServer

	connectionCallback 	ConnectionCallback
	messageCallback    	MessageCallback
	closeCallback      	CloseCallback
	timerCallback 		TimerCallback

	splitter ISplitter

	port 				int
	PluginPath 			string
	Clients *sync.Map
}

func NewServer(port int, pluginPath string, splitter ISplitter) *Server {
	s := &Server{
		splitter: splitter,
		port:      port,
		PluginPath: pluginPath,
		Clients:    new(sync.Map),
	}
	return s
}

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

func (s *Server) GetIConnection(id int) IConnection {
	c, ok := s.Clients.Load(id)
	if !ok {
		return nil
	}
	return c.(IConnection)
}

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) newConnection(conn IConnection) {
	s.Clients.Store(conn.GetID(), conn)

	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)
	s.Clients.Delete(conn.GetID())
}

func (s *Server) LoadPlugin() {
	//重新加载
	_, err:=plugin.Open(s.PluginPath)
	if err != nil {
		logger.Error("load plugin err: %v, %s", err, s.PluginPath)
		return
	}
	logger.Debug("load plugin success")
}


func (s *Server) Start() error {
	//初始化plugin
	//_, err = plugin.Open(conf.GlobalConf.GameConf.PluginPath)
	//if 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()
	s.Clients.Range(func(key, value interface{}) bool {
		client := value.(IConnection)
		client.Stop()
		return true
	})
}