#include "response.h"
#include "socket-common.h"
#include "i2c.h"
#include <string.h>
#include <stdlib.h>
#include <glib.h>

//RESPONSE related functions from the server

extern guint signalMyCb; //signal id
extern GAsyncQueue* stdinQueue; //our queue
SignalObject* signalObject; //the signal object which registered the signal id

//write output to client
static gssize writeOutput(GPollableOutputStream* stream, gchar* data, gssize size);

//callback for client output, this is where the queue messages are sent to the client
gboolean cbClientOutput(gpointer data, gpointer additional)
{
	GPollableOutputStream* outStream = (GPollableOutputStream*)data;
	GAsyncQueue* queue = (GAsyncQueue*)additional;
	if(g_async_queue_length(queue) <= 0) {
		return FALSE;
	}

	gpointer elem;
	g_print_debug("Try pop\n");
	//try to pop an element from the queue
	elem=g_async_queue_try_pop(queue);
	g_print_debug("after pop\n");
	if(elem) {
		char* buf = (char*)elem;
		g_print_debug("Extracted %s\n", buf);
		gssize size = strlen(buf);
		gssize written = 0;

		written=g_pollable_output_stream_write_nonblocking(outStream, buf, size+1, NULL, NULL);
		if(written==-1) {
			g_printerr("Could not write to client\n");
		}

		//free the alloc'ed memory
		free(buf);
	}

	return FALSE;
}

//the client input callback
gboolean cbClientInput(gpointer data, gpointer additional)
{

	char buffer[1024];
	gssize size=0;
	memset(buffer,0,1024);

	GPollableInputStream* inStream = (GPollableInputStream*)data;
	GPollableOutputStream* outStream = (GPollableOutputStream*)additional;

	size=g_pollable_input_stream_read_nonblocking(inStream, buffer, 1024, NULL, NULL);
	if(size == -1) {
		g_print_debug("Got: %d\n", size);
		return FALSE;
	}

	//emit a signal which calls the responseCb function
	SignalObjectClass myStruct;
	myStruct.instance = NULL;
	myStruct.cb = writeOutput;
	myStruct.data = buffer;
	myStruct.size = size;
	myStruct.inStream = inStream;
	myStruct.outStream = outStream;
	g_signal_emit(signalObject, signalMyCb, 0, &myStruct, NULL);

	return TRUE;
}

//write output to client
static gssize writeOutput(GPollableOutputStream* stream, gchar* data, gssize size)
{
	return g_pollable_output_stream_write_nonblocking(stream, data, size, NULL, NULL);
}

//initialize the signals
void initSignals(guint *signal)
{
	*signal = g_signal_new("runEchoService", SIGNAL_OBJECT_TYPE, G_SIGNAL_RUN_FIRST, 0, NULL, NULL,
	                       g_cclosure_marshal_VOID__POINTER , G_TYPE_NONE, 1, G_TYPE_POINTER);

	signalObject = g_object_new(SIGNAL_OBJECT_TYPE, NULL);
	g_signal_connect (signalObject, "runEchoService", G_CALLBACK (responseCb), NULL);
}

//send to client 3 times
void responseCb(gpointer instance, GObject *arg1, gpointer user_data)
{
        static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
        g_static_mutex_lock (&mutex);
        SignalObjectClass *data = (SignalObjectClass*)arg1;
        GPollableOutputStream* stream = (GPollableOutputStream*)data->outStream;
        gchar* str = data->data;
        gssize len = data->size;
        gssize written = 0;

	// remove leading and trailing whitespace
	g_strstrip (str);

	I2C_Write (0x3b, 0xff);
	guchar status = I2C_Read (0x3b);

	// dummy response function
        gchar* upper = g_ascii_strup(str, len);
	gchar *out_string = g_strdup_printf("%s\n%s\n%s\n%d\n",upper,upper,upper,status);
	gssize out_len = strlen (out_string);

        //send response back to client
        written = data->cb(stream, out_string, out_len);
        if(written == -1) {
                g_print_debug("Could not send message to client\n");
        }

        g_free(upper);
	g_free(out_string);

        g_static_mutex_unlock (&mutex);
}