package tcp

import (
	"context"

	"spark-server/internal/pkg/errs"
	"spark-server/internal/transport/tcp/protocol"
	"spark-server/internal/transport/tcp/session"
)

func (s *Server) registerDefaultHandlers() {
	s.router.Register(protocol.CmdAuth, s.handleAuth)
	s.router.Register(protocol.CmdGenerateMsgID, s.handleGenerateMsgID)
}

func (s *Server) handleAuth(ctx context.Context, conn *session.Conn, frame protocol.Frame) (*protocol.Frame, error) {
	if s.auth == nil {
		return nil, errs.ErrUnauthorized
	}
	req, err := protocol.DecodeAuthRequest(frame.Body)
	if err != nil {
		return nil, errs.ErrInvalidArgument
	}
	principal, err := s.auth.Authenticate(ctx, req.Token)
	if err != nil {
		return nil, err
	}
	deviceID := principal.DeviceID
	if req.DeviceID != 0 {
		deviceID = req.DeviceID
	}
	conn.Authenticate(principal.UserID, deviceID)
	if err := s.sessions.Bind(conn); err != nil {
		return nil, err
	}
	conn.Activate()
	body := protocol.EncodeAuthResponse(protocol.AuthResponse{UserID: principal.UserID, DeviceID: deviceID})
	return &protocol.Frame{
		Version: protocol.CurrentVersion, Command: protocol.CmdAuth,
		RequestID: frame.RequestID, SequenceID: frame.SequenceID, Body: body,
	}, nil
}

func (s *Server) handleGenerateMsgID(_ context.Context, conn *session.Conn, frame protocol.Frame) (*protocol.Frame, error) {
	if s.ids == nil {
		return nil, errs.ErrInternal
	}
	if !conn.Authenticated() {
		return nil, errs.ErrUnauthorized
	}
	id, err := s.ids.NextMsgID()
	if err != nil {
		return nil, err
	}
	return &protocol.Frame{
		Version: protocol.CurrentVersion, Command: protocol.CmdGenerateMsgID,
		RequestID: frame.RequestID, SequenceID: frame.SequenceID, Body: protocol.EncodeMsgID(id),
	}, nil
}