package comms

import (
	"encoding/gob"
	"os"
	"os/user"
	"runtime"
	"time"
)

const PROTOCOL_VERSION = 1

func init() {
	RegisterEventsWithGob()
}

// Client to server events

type AgentInfo struct {
	Username string
	Hostname string
	Pwd      string
	OS       string
}

type ClientInfo struct {
	ClientId int
}

type SessionInfo struct {
	ClientId string

	// "ssh", "sftp"
	SessionType string
}

type ExpiryTimeUpdate struct {
	ExpiryTime time.Time
}

type HeartBeat struct {
	// Empty
}

type ProtocolVersion struct {
	Version int
}

type UserPassword struct {
	Username string
	Password string
}

// initialization mesaage when agent connects to server

type ServerInfo struct {
	UserPassword UserPassword
}

// confirmation message when agent connects
type AgentRegistration struct {
	Ok      bool
	Message string
	// final Id assigned by the server. Usually identical to the requested id
	// but if there is a conflict, a new id is chosen.
	Id string
}

// Generic wrapper message required to send messages of arbitrary type

type ConvergeMessage struct {
	Value interface{}
}

func NewAgentInfo() AgentInfo {
	username, _ := user.Current()
	host, _ := os.Hostname()
	pwd, _ := os.Getwd()
	return AgentInfo{
		Username: username.Username,
		Hostname: host,
		Pwd:      pwd,
		OS:       runtime.GOOS,
	}
}

func NewSessionInfo(clientId, sessionType string) SessionInfo {
	return SessionInfo{
		ClientId:    clientId,
		SessionType: sessionType,
	}
}

func NewExpiryTimeUpdate(expiryTime time.Time) ExpiryTimeUpdate {
	return ExpiryTimeUpdate{ExpiryTime: expiryTime}
}

func RegisterEventsWithGob() {
	// Agent to ConvergeServer
	gob.Register(AgentInfo{})
	gob.Register(SessionInfo{})
	gob.Register(ExpiryTimeUpdate{})
	gob.Register(HeartBeat{})

	// ConvergeServer to Agent
	gob.Register(ProtocolVersion{})
	gob.Register(UserPassword{})

	// Wrapper event.
	gob.Register(ConvergeMessage{})
}