package main

import (
	"encoding/binary"
	"fmt"
	"io"
	"net"
)

type GrainHandler struct {
	listener net.Listener
	pool     *GrainLocalPool
}

func (h *GrainHandler) GetState(id CartId, reply *Grain) error {
	grain, err := h.pool.GetGrain(id)
	if err != nil {
		return err
	}
	*reply = grain
	return nil
}

func NewGrainHandler(pool *GrainLocalPool, listen string) (*GrainHandler, error) {
	handler := &GrainHandler{
		pool: pool,
	}
	l, err := net.Listen("tcp", listen)
	handler.listener = l
	return handler, err
}

func (h *GrainHandler) Serve() {
	for {
		conn, err := h.listener.Accept()
		if err != nil {
			fmt.Println("Error accepting connection:", err)
			continue
		}

		go h.handleClient(conn)
	}
}

func (h *GrainHandler) handleClient(conn net.Conn) {
	var err error
	fmt.Println("Handling client connection")
	defer conn.Close()

	var packet CartPacket
	for {
		for {
			err = binary.Read(conn, binary.LittleEndian, &packet)
			if err != nil {
				if err == io.EOF {
					break
				}
				fmt.Println("Error in connection:", err)
			}
			if packet.Version != 2 {
				fmt.Printf("Unknown version %d", packet.Version)
				break
			}

			switch packet.MessageType {
			case RemoteHandleMessage:
				fmt.Printf("Handling message\n")
				var msg Message
				err = MessageFromReader(conn, &msg)
				if err != nil {
					fmt.Println("Error reading message:", err)
				}
				fmt.Printf("Message: %s, %v\n", packet.Id.String(), msg)
				grain, err := h.pool.Process(packet.Id, msg)
				if err != nil {
					fmt.Println("Error handling message:", err)
				}
				SendProxyResponse(conn, grain)

			case RemoteGetState:
				fmt.Printf("Package: %s %v\n", packet.Id.String(), packet)
				grain, err := h.pool.Get(packet.Id)
				if err != nil {
					fmt.Println("Error getting grain:", err)
				}
				SendProxyResponse(conn, grain)
			}

		}

	}
}