package protocol

import (
	"time"
)

type PacketType int

const (
	ReqUserCertPkt PacketType = iota
	ReqAllMsgPkt
	ReqMsgPkt
	SubmitMsgPkt
	SendUserCertPkt
	ServerMsgPkt
)

type PacketBody interface{}

type Packet struct {
	Flag PacketType
	Body PacketBody
}

// Client --> Server: Ask for a user's certificate
type RequestUserCertPacket struct {
	UID string
}

func NewRequestUserCertPacket(UID string) Packet {
	return Packet{
		Flag: ReqUserCertPkt,
		Body: RequestUserCertPacket{
			UID: UID,
		},
	}
}

// Client --> Server: Ask for all the client's messages in the queue
type RequestAllMsgPacket struct {
	FromUID string
}

func NewRequestAllMsgPacket(fromUID string) Packet {
	return Packet{
		Flag: ReqAllMsgPkt,
		Body: RequestAllMsgPacket{
			FromUID: fromUID,
		},
	}
}

// Client --> Server: Ask for a specific message in the queue
type RequestMsgPacket struct {
	Num uint16
}

func NewRequestMsgPacket(num uint16) Packet {
	return Packet{
		Flag: ReqMsgPkt,
		Body: RequestMsgPacket{
			Num: num,
		},
	}
}

// Client --> Server: Send message from client to server
type SubmitMessagePacket struct {
	ToUID   string
	Content []byte
}

func NewSubmitMessagePacket(toUID string, content []byte) Packet {
	return Packet{
		Flag: SubmitMsgPkt,
		Body: SubmitMessagePacket{
			ToUID:   toUID,
			Content: content},
	}
}

// Server --> Client: Send the client the requested public key
type SendUserCertPacket struct {
	UID string
	Key []byte
}

func NewSendUserCertPacket(uid string, key []byte) Packet {
	return Packet{
		Flag: SendUserCertPkt,
		Body: SendUserCertPacket{
			UID: uid,
			Key: key,
		},
	}
}

// Server --> Client: Send the client a message
type ServerMessagePacket struct {
	FromUID   string
	ToUID     string
	Content   []byte
	Timestamp time.Time
}

func NewServerMessagePacket(fromUID, toUID string, content []byte, timestamp time.Time) Packet {
	return Packet{
		Flag: ServerMsgPkt,
		Body: ServerMessagePacket{
			FromUID:   fromUID,
			ToUID:     toUID,
			Content:   content,
			Timestamp: timestamp,
		},
	}
}