package main

import (
	"bytes"
	"flag"
	"fmt"
	"git.xdrm.io/logauth/schastsp/client"
	"git.xdrm.io/logauth/schastsp/context"
	"git.xdrm.io/logauth/schastsp/server"
	"os"
	"time"
)

/* Store target config paths */
var clientConfigPath = "/tmp/cyclichash/client/"
var serverConfigPath = "/tmp/cyclichash/server/lastkey"

func main() {

	executionStart := time.Now().UnixNano()

	/* (1) Create context
	---------------------------------------------------------*/
	/* (1) Create it */
	ctx, err := context.Create(2, 0x0f0, 0x0a, 0xfff)
	if err != nil {
		fmt.Printf("[ERROR:context] %s\n", err)
		return
	}

	/* (2) Manage flags (cli arguments)
	---------------------------------------------------------*/
	/* (1) Define 'sync' mode */
	var sync bool
	flag.BoolVar(&sync, "sync", false, "If set, a new synchronisation key will be outputed\nNote: it will break existing systems")

	/* (2) Define connection 'latency' */
	var latency int64
	flag.Int64Var(&latency, "t", 0, "Connection latency in ms")

	/* (3) Parse cli arguments */
	flag.Parse()

	/* (4) Dispatch to functions */
	if sync {
		synchronise(ctx)
	} else {
		testCommunication(ctx, latency)
	}

	executionStop := time.Now().UnixNano()
	nsElapsed := float64(executionStop - executionStart)
	usElapsed := float64(nsElapsed / 1e3)
	msElapsed := float64(usElapsed / 1e3)
	sElapsed := float64(msElapsed / 1e3)

	if sElapsed >= 1 {
		fmt.Printf("executed in %.3f s\n", sElapsed)
	} else if msElapsed >= 1 {
		fmt.Printf("executed in %.3f ms\n", msElapsed)
	} else if usElapsed >= 1 {
		fmt.Printf("executed in %.3f us\n", usElapsed)
	} else if nsElapsed >= 1 {
		fmt.Printf("executed in %.3f ns\n", nsElapsed)
	}

	return
}

func synchronise(ctx *context.T) {

	/* (1) Create client */
	client, err := client.New(ctx, clientConfigPath)
	if err != nil {
		fmt.Printf("[ERROR:client] %s\n", err)
		return
	}

	/* (2) Get synchronisation key */
	syncKey, err := client.SynchronisationKey()
	if err != nil {
		fmt.Printf("[ERROR:syncKey] %s\n", err)
		return
	}

	/* (3) Store synchronisation key */
	conf, err := os.OpenFile(serverConfigPath, os.O_RDWR|os.O_CREATE, 0775)
	if err != nil {
		fmt.Printf("[ERROR:syncKey:storage] %s\n", err)
		return
	}

	defer conf.Close()

	conf.Write(syncKey)

	fmt.Printf("Synchronisation Key stored\n")

	return

}

func testCommunication(ctx *context.T, latency int64) {

	/* (1) Setup
	---------------------------------------------------------*/
	/* (1) Create client */
	client, err := client.New(ctx, clientConfigPath)
	if err != nil {
		fmt.Printf("[ERROR:client] %s\n", err)
		return
	}

	/* (2) Create server */
	server, err := server.New(ctx, serverConfigPath)
	if err != nil {
		fmt.Printf("[ERROR:server] %s\n", err)
		return
	}

	/* (3) Create emulation buffers */
	requestSocket, responseSocket := new(bytes.Buffer), new(bytes.Buffer)

	/* (2) REAL STUFF HAPPENS HERE
	---------------------------------------------------------*/
	/* (1) Request  | client send */
	err = client.Send(requestSocket)
	if err != nil {
		fmt.Printf("[ERROR:request:send] %s\n", err)
		return
	}

	/* (2) Emulate latency */
	time.Sleep(time.Duration(latency) * time.Second / 1e3)

	/* (3) Request  | server receive */
	/*     Response | server send    */
	err = server.HandleRequest(requestSocket, responseSocket)
	if err != nil {
		fmt.Printf("[ERROR:request:receive] %s\n", err)
		return
	}

	/* (4) Response | client receive */
	err = client.Receive(responseSocket)
	if err != nil {
		fmt.Printf("[ERROR:response:receive] %s\n", err)
		return
	}

	return

}