package main

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

func main(){

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

	/* (1) Flag management (cli arguments)
	---------------------------------------------------------*/
	/* (1) Secret folder */
	clientConfigPath := flag.String("file", "/tmp/schastsp_keys", "Configuration folder, it will contain sensitive data (keys), make sure to control it properly. (default: /tmp/schastsp_keys)")

	/* (2) request | response */
	isRequest := flag.Bool("req", false, "Will generate a request into standard output.")
	isResponse := flag.Bool("res", false, "Will proceed a response management from standard input.")

	/* (3) Context window size */
	winSize := flag.Uint("win", 2000, "Time window value in ms. (default: 2000)")

	/* (4) Context minimum depth value */
	minDepth := flag.Uint("min", 0x0f0, "Minimum depth value. (default: 240)")

	/* (5) Context maximum depth value */
	maxDepth := flag.Uint("max", 0xfff, "Maximum depth value. (default: 4095)")

	/* (6) Context depth threshold */
	thrDepth := flag.Uint("thr", 0x00a, "Depth threshold protecting minimum depth to be reached. (default: 10)")

	/* (7) Synchronisation request (special order) */
	syncRequest := flag.Bool("sync", false, "If set, proceeds a synchronisation request and outputs the synchronisation key.")

	/* (8) Parse flags */
	flag.Parse()


	/* (2) Create context + client
	---------------------------------------------------------*/
	/* (1) Create context */
	ctx, err := context.Create( float64(*winSize) / 1e3, uint16(*minDepth), uint16(*thrDepth), uint16(*maxDepth) );
	if err != nil { os.Stderr.WriteString( fmt.Sprintf("[CLIENT_ERROR:context] %s\n", err) ); return }

	/* (2) Create client */
	cli, err := client.New(ctx, *clientConfigPath)
	if err != nil { os.Stderr.WriteString( fmt.Sprintf("[CLIENT_ERROR:client] %s\n", err) ); return }



	/* (3) Dispatch execution
	---------------------------------------------------------*/
	/* (1) If synchronisation request */
	if *syncRequest {
		synchronisationRequest(cli);

	/* (2) If request */
	} else if *isRequest {

		err = cli.Send(os.Stdout)
		if err != nil { os.Stderr.WriteString( fmt.Sprintf("[CLIENT_ERROR:request] %s\n", err) ) }

	/* (3) If response */
	} else if *isResponse {

		err = cli.Receive(os.Stdin)
		if err != nil { os.Stderr.WriteString( fmt.Sprintf("[CLIENT_ERROR:response] %s\n", err) ); return }

	/* (4) Else -> nothing */
 	}else {
		os.Stderr.WriteString( fmt.Sprintf("Missing argument.\n\nYou must give one of the 3 available actions :\n  -req to manage a request\n  -res to manage a response\n  -sync to get a synchronisation key\n") )
	}





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

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

	return
}




func synchronisationRequest(cli *client.T){

	/* (1) Get synchronisation key */
	syncKey, err := cli.SynchronisationKey()
	if err != nil { fmt.Errorf("[CLIENT_ERROR:syncKey] %s\n", err); return }

	/* (2) Print synchronisation key */
	os.Stdout.Write(syncKey)

	return;

}