From 6e6ca1d7a10a3a4a1decbdb78e2ea11ce24974e3 Mon Sep 17 00:00:00 2001
From: Kyren223 <ulmliad223@gmail.com>
Date: Thu, 17 Oct 2024 17:12:57 +0300
Subject: feat: add ui for client

---
 internal/server/handler.go | 54 +++++++++++++++++++++++-----------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

(limited to 'internal/server')

diff --git a/internal/server/handler.go b/internal/server/handler.go
index cf1eb82..0ab5c33 100644
--- a/internal/server/handler.go
+++ b/internal/server/handler.go
@@ -6,11 +6,13 @@ import (
 	"fmt"
 	"log"
 	"net"
+	"strings"
 	"sync"
 	"time"
 
 	"github.com/kyren223/eko/internal/data"
 	"github.com/kyren223/eko/internal/packet"
+	"github.com/kyren223/eko/pkg/assert"
 	"github.com/kyren223/eko/pkg/snowflake"
 )
 
@@ -23,12 +25,14 @@ func handleConnection(conn net.Conn, wg *sync.WaitGroup) {
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
 	defer cancel()
 	out, outErr := packet.RunFramer(ctx, conn)
-	log.Printf("client %v: running framer\n", conn.RemoteAddr().String())
 
 outer:
 	for {
 		select {
-		case packet := <-out:
+		case packet, ok := <-out:
+			if !ok {
+				break outer
+			}
 			log.Printf("client %v: request packet: %v\n", conn.RemoteAddr().String(), packet)
 			responsePacket, err := handlePacket(packet)
 			log.Printf("client %v: response packet: %v\n", conn.RemoteAddr().String(), responsePacket)
@@ -43,16 +47,13 @@ outer:
 			}
 
 		case err := <-outErr:
-			if err == nil {
-				continue
-			}
 			if err == packet.PacketUnsupportedEncoding {
 				err := unsupportedEncodingErrorPacket.Into(conn)
 				log.Printf("client %v: error writing unsupported encoding packet: %v\n", conn.RemoteAddr().String(), err)
 			} else if err == packet.PacketUnsupportedType {
 				err := unsupportedTypeErrorPacket.Into(conn)
 				log.Printf("client %v: error writing unsupported type packet: %v\n", conn.RemoteAddr().String(), err)
-			} else {
+			} else if err != nil {
 				log.Printf("client %v: internal error: %v\n", conn.RemoteAddr().String(), err)
 			}
 			break outer
@@ -65,6 +66,7 @@ outer:
 }
 
 func handlePacket(pkt packet.Packet) (packet.Packet, error) {
+	var response packet.TypedMessage
 	switch pkt.Type() {
 	case packet.TypeEko:
 		var request packet.EkoMessage
@@ -72,51 +74,49 @@ func handlePacket(pkt packet.Packet) (packet.Packet, error) {
 			return packet.Packet{}, fmt.Errorf("decode error: %v", err)
 		}
 
-		response := packet.EkoMessage{Message: "Eko \"" + request.Message + "\""}
-		encoder, err := packet.NewMsgPackEncoder(&response)
-		if err != nil {
-			return packet.Packet{}, fmt.Errorf("encode error: %v", err)
-		}
-		return packet.NewPacket(encoder), nil
+		response = &packet.EkoMessage{Message: "Eko \"" + request.Message + "\""}
 	case packet.TypeSendMessage:
 		var request packet.SendMessageMessage
 		if err := pkt.DecodePayload(&request); err != nil {
 			return packet.Packet{}, fmt.Errorf("decode error: %v", err)
 		}
 
+		content := strings.TrimSpace(request.Content)
+		if content == "" {
+			response = &packet.ErrorMessage{Error: "content must not be blank"}
+			break
+		}
+
 		message := data.Message{
 			Id:          node.Generate(),
 			SenderId:    node.Generate(),
 			FrequencyId: node.Generate(),
 			NetworkId:   node.Generate(),
-			Contents:    request.Content,
+			Contents:    content,
 		}
 		messages = append(messages, message)
 
-		response := packet.EkoMessage{Message: "Eko OK"}
-		encoder, err := packet.NewMsgPackEncoder(&response)
-		if err != nil {
-			return packet.Packet{}, fmt.Errorf("encode error: %v", err)
-		}
-		return packet.NewPacket(encoder), nil
+		response = &packet.EkoMessage{Message: "Eko OK"}
 	case packet.TypeGetMessages:
 		var request packet.GetMessagesMessage
 		if err := pkt.DecodePayload(&request); err != nil {
 			return packet.Packet{}, fmt.Errorf("decode error: %v", err)
 		}
 
-		response := packet.MessagesMessage{Messages: messages}
-		encoder, err := packet.NewMsgPackEncoder(&response)
-		if err != nil {
-			return packet.Packet{}, fmt.Errorf("encode error: %v", err)
-		}
-		return packet.NewPacket(encoder), nil
+		response = &packet.MessagesMessage{Messages: messages}
 	default:
 		return packet.Packet{}, errors.New("TODO: not implemented yet")
 	}
+
+	assert.NotNil(response, "response must always be set")
+	encoder, err := packet.NewMsgPackEncoder(response)
+	if err != nil {
+		return packet.Packet{}, fmt.Errorf("encode error: %v", err)
+	}
+	return packet.NewPacket(encoder), nil
 }
 
 var (
-	node                    = snowflake.NewNode(1)
-	messages []data.Message = make([]data.Message, 10)
+	node     = snowflake.NewNode(1)
+	messages []data.Message
 )
-- 
cgit v1.3.1