package event

import (
	"context"
	"errors"
	"fmt"
	"gitee.com/simple-set/simple.io/src/socket"
	"io"
	"log/slog"
	"net"
	"reflect"
)

// StarterServer 服务端启动器接口
type StarterServer interface {
	Listen() error
	Listener() net.Listener
	Close() error
}

// 服务端模式的启动器
type starterServer struct {
	ctx    context.Context
	server socket.Server
	event  *Event
}

func newStarterServer(server socket.Server, event *Event, ctx context.Context) *starterServer {
	return &starterServer{server: server, event: event, ctx: ctx}
}

func (s *starterServer) Listen() error {
	for {
		sock, err := s.server.Listen()
		if err != nil {
			// 监听新会话异常
			_ = s.Close()
			return err
		} else {
			// 创建并处理新会话
			go s.handler(NewSessionContext(sock, s.ctx))
		}
	}
}

func (s *starterServer) Close() error {
	if s.server == nil {
		return errors.New("server is nil")
	}
	return s.server.Close()
}

func (s *starterServer) Listener() net.Listener {
	return s.server.Listener()
}

func (s *starterServer) handler(session *Session) {
	remoteAddr := session.Socket.RemoteAddr().String()
	if s.event == nil {
		slog.Error("event is nil", "client", remoteAddr)
		_ = session.Close()
		return
	}

	session.setState(Accept)
	if err := s.execAccept(session); err != nil {
		slog.Error("execAccept exception", "client", remoteAddr, "err", err.Error())
		_ = session.Close()
		return
	}

	session.setState(Active)
	if err := s.execActive(session); err != nil {
		slog.Error("execActive exception", "client", remoteAddr, "err", err.Error())
		_ = session.Close()
		return
	}

	session.setState(Disconnect)
	if err := s.execDisconnect(session); err != nil {
		slog.Error("execDisconnect exception", "client", remoteAddr, "err", err.Error())
		_ = session.Close()
		return
	}

	if !session.Socket.IsUdp() {
		if err := session.Close(); err != nil {
			slog.Warn("session.close error,", "client", remoteAddr, "err", err.Error())
		}
	}
	slog.Debug(fmt.Sprintf("%s, disconnect from %s", reflect.ValueOf(s.server).Elem().Type().String(), remoteAddr))
	return
}

func (s *starterServer) execAccept(session *Session) error {
	if session.state != Accept {
		return fmt.Errorf("execAccept reject, Session state mismatch, %v", session.state)
	}
	_, err := s.event.execute(session, nil)
	return err
}

func (s *starterServer) execActive(session *Session) error {
	if session.state != Active {
		return fmt.Errorf("execActive reject, Session state mismatch, %v", session.state)
	}

	for {
		if err := session.Socket.Wait(); err == io.EOF {
			return nil
		} else if err != nil {
			return err
		}

		if _, err := s.event.execute(session, nil); err == io.EOF {
			return nil
		} else if err != nil {
			return err
		}
	}
}

func (s *starterServer) execDisconnect(session *Session) error {
	if session.state != Disconnect {
		return fmt.Errorf("execDisconnect reject, Session state mismatch, %v", session.state)
	}
	_, err := s.event.execute(session, nil)
	return err
}