package main

import (
	"encoding/binary"
	"fmt"
	"log"
	"time"
)

type CartClient struct {
	*CartTCPClient
}

func CartDial(address string) (*CartClient, error) {

	mux, err := NewCartTCPClient(address)
	if err != nil {
		return nil, err
	}
	client := &CartClient{
		CartTCPClient: mux,
	}
	return client, nil
}

func (c *Client) Close() {
	c.Conn.Close()
}

type CartTCPClient struct {
	*PersistentConnection
	ErrorCount int
	address    string
	*CartPacketQueue
}

func NewCartTCPClient(address string) (*CartTCPClient, error) {
	connection, err := NewPersistentConnection(address)
	if err != nil {
		return nil, err
	}
	return &CartTCPClient{
		ErrorCount:           0,
		PersistentConnection: connection,
		address:              address,
		CartPacketQueue:      NewCartPacketQueue(connection),
	}, nil
}

func (m *CartTCPClient) SendPacket(messageType uint32, id CartId, data []byte) error {

	err := binary.Write(m.Conn, binary.LittleEndian, CartPacket{
		Version:     CurrentPacketVersion,
		MessageType: messageType,
		DataLength:  uint32(len(data)),
		Id:          id,
	})
	if err != nil {
		return m.HandleConnectionError(err)
	}
	_, err = m.Conn.Write(data)
	return m.HandleConnectionError(err)
}

func (m *CartTCPClient) Call(messageType uint32, id CartId, responseType uint32, data []byte) (*CallResult, error) {
	packetChan := m.Expect(responseType, id)
	err := m.SendPacket(messageType, id, data)
	if err != nil {
		return nil, m.HandleConnectionError(err)
	}
	select {
	case ret := <-packetChan:
		return &ret, nil
	case <-time.After(time.Second):
		log.Printf("Timeout waiting for cart response to message type %d\n", responseType)
		return nil, m.HandleConnectionError(fmt.Errorf("timeout"))
	}
}