package client

import (
	"net"

	"go.rctt.net/solec/core"
)

type Handler interface {
	HandleMessage(msg core.Message)
	HandleError(err error)
}

type Client struct {
	h    Handler
	conn net.Conn

	addr  string
	uname string
	pass  string
}

func NewClient(handler Handler, addr, uname, pass string) *Client {
	return &Client{
		h:     handler,
		addr:  addr,
		uname: uname,
		pass:  pass,
	}
}

func (c *Client) Connect() error {
	var err error
	c.conn, err = net.Dial("tcp", c.addr)
	if err != nil {
		return err
	}
	defer c.conn.Close()

	hs := core.Handshake{0, 1}
	if err := core.Send(c.conn, hs); err != nil {
		return err
	}

	auth := core.Auth{c.uname, c.pass}
	if err := core.Send(c.conn, auth); err != nil {
		return err
	}

	c.read()
	return nil
}

func (c *Client) SendMessage(target, content string) error {
	msg := core.Message{
		Source:  c.uname + "@" + c.addr,
		Target:  target,
		Content: content,
	}

	return core.Send(c.conn, msg)
}

func (c *Client) read() {
	for {
		payload, err := core.Read(c.conn)
		if err != nil {
			c.h.HandleError(err)
		}

		c.handlePayload(payload)
	}
}

func (c *Client) handlePayload(payload any) {
	switch v := payload.(type) {
	case core.Message:
		c.h.HandleMessage(v)
	}
}