/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/


#include<stdio.h>  
#include "test-utils.h"
#include<string.h> 
#include<ctype.h>
#include<unistd.h>  
#define TEST_BUS_NAME_TEMP "Test.Method.Call"
 
void called_method(DBusMessage* msg, DBusConnection* connection)
{
	DBusMessage* reply; 
	DBusMessageIter args;
	DBusMessageIter in_args;
	
	char* in_str;
	DBusError error;
	   
	dbus_uint32_t status = 94;

	dbus_error_init(&error);
	dbus_message_iter_init(msg, &in_args);
	 
	reply = dbus_message_new_method_return(msg);
	dbus_message_iter_init_append(reply, &args);
	  
	do{
		dbus_message_iter_get_basic(&in_args, &in_str);
					
		dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &in_str);
		
	}while(dbus_message_iter_next(&in_args));
	 
	dbus_connection_send(connection, reply, NULL);
	
	dbus_connection_flush(connection);
}


void called_variable_args_method(DBusMessage* msg, DBusConnection* connection)
{
	DBusMessage* reply;
	DBusMessageIter iter;
	DBusMessageIter sub_iter;
	void* arg = malloc(20);
	char* str;
	int no;
	int i;
	dbus_int32_t* array;
	dbus_int32_t return_value = 0;
	dbus_bool_t valid_flag = TRUE;
	

	
	
	reply = dbus_message_new_method_return(msg);
	dbus_message_iter_init(msg, &iter);
	
	do{
		switch(dbus_message_iter_get_arg_type(&iter))
		{
			case DBUS_TYPE_BOOLEAN:
				dbus_message_iter_get_basic(&iter, arg);
				if(*(dbus_bool_t*)arg != TRUE)
					valid_flag = FALSE;
				break;
			case DBUS_TYPE_INT16:
				dbus_message_iter_get_basic(&iter, arg);
				if(*(dbus_int16_t*)arg != -16)
					valid_flag = FALSE;
				break;
			case DBUS_TYPE_INT32:
				dbus_message_iter_get_basic(&iter, arg);
				if(*(dbus_int32_t*)arg != -32)
					valid_flag = FALSE;
				break;
			case DBUS_TYPE_INT64:
				dbus_message_iter_get_basic(&iter, arg);
				if(*(dbus_int64_t*)arg != -64)
					valid_flag = FALSE;
				break;
			case DBUS_TYPE_UINT16:
				dbus_message_iter_get_basic(&iter, arg);
				if(*(dbus_uint16_t*)arg != 16)
					valid_flag = FALSE;
				break;
			case DBUS_TYPE_UINT32:
				dbus_message_iter_get_basic(&iter, arg);
				if(*(dbus_uint32_t*)arg != 32)
					valid_flag = FALSE;
				break;
			case DBUS_TYPE_UINT64:
				dbus_message_iter_get_basic(&iter, arg);
				if(*(dbus_uint64_t*)arg != 64)
					valid_flag = FALSE;
				break;
			case DBUS_TYPE_DOUBLE:
				dbus_message_iter_get_basic(&iter, arg);
				if(*(double*)arg != 12.34567)
					valid_flag = FALSE;
				break;
			case DBUS_TYPE_STRING:
				dbus_message_iter_get_basic(&iter, &str);
				if(strcmp("DBus Testing", str))
					valid_flag = FALSE;
				break;
			case DBUS_TYPE_ARRAY: 
				dbus_message_iter_recurse(&iter, &sub_iter);
				no = dbus_message_iter_get_array_len(&sub_iter);
				dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);
				for(i=0;i<no;i++)
					if(array[i] != (i+1))
						valid_flag = FALSE;
				break;
			case DBUS_TYPE_STRUCT: 
				dbus_message_iter_recurse(&iter, &sub_iter);
				do{
					switch(dbus_message_iter_get_arg_type(&sub_iter))
					{
					case DBUS_TYPE_INT32: 
						dbus_message_iter_get_basic(&sub_iter, arg);
						if(*(dbus_int32_t*)arg != -32)
							valid_flag = FALSE;
						break;    
					case DBUS_TYPE_STRING:
						dbus_message_iter_get_basic(&sub_iter, &str);
						if(strcmp("DBus Testing", str))
							valid_flag = FALSE;
						break;
					case DBUS_TYPE_DOUBLE:
						dbus_message_iter_get_basic(&sub_iter, arg);
						if(*(double*)arg != 12.34567)
							valid_flag = FALSE;
						break;
					default: 
						valid_flag = FALSE;
					
					}                               
				}while(dbus_message_iter_next(&sub_iter));
				
				break; 
			default: 
				valid_flag = FALSE;
		}
	}while(dbus_message_iter_next(&iter));
	
	if(!valid_flag)
		return_value = 1;
	else
		return_value = 0;
	
	dbus_message_append_args(reply, DBUS_TYPE_INT32, &return_value, DBUS_TYPE_INVALID);
	dbus_connection_send(connection, reply, NULL);
	dbus_connection_flush(connection);
}
 
void called_simple(DBusMessage* msg, DBusConnection* connection)
{
	DBusMessage* reply;	
	dbus_int32_t return_value = 9090;
	
	reply = dbus_message_new_method_return(msg);
	
	dbus_message_append_args(reply, DBUS_TYPE_INT32, &return_value, DBUS_TYPE_INVALID);
	dbus_connection_send(connection, reply, NULL);
	dbus_connection_flush(connection);
}


void called_file_send(DBusMessage* msg, DBusConnection* connection)
{
	DBusMessage* reply;
	int return_value = 8080;
	DBusMessageIter iter;
	DBusMessageIter sub_iter;
	int no; 
	unsigned char* array;
	FILE* fp=NULL; 
	
	dbus_message_iter_init(msg, &iter);
	dbus_message_iter_recurse(&iter, &sub_iter);
	no = dbus_message_iter_get_array_len(&sub_iter);
	dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);
	
	fp = fopen("c:\\data\\images\\pictures\\bunbask1.jpg", "a+"); 
	if(!fp) 
	{
		printf("Failed to open file");
		return;
	}
	
	fwrite(array, sizeof(unsigned char), no, fp);
	
	if(fp)
		fclose(fp);
	
	reply = dbus_message_new_method_return(msg);
	dbus_connection_send(connection, reply, NULL);
	dbus_connection_flush(connection);
}

void called_file_send_time(DBusMessage* msg,DBusConnection* connection)
	{
		DBusMessageIter iter;
		DBusMessageIter sub_iter;
		int no; 
		unsigned char* array;
		FILE* fp=NULL; 
		DBusMessage* reply;
		char* file_name;
		
		reply = dbus_message_new_method_return(msg);
		dbus_connection_send(connection, reply, NULL);
		dbus_connection_flush(connection);
		
		dbus_message_iter_init(msg, &iter);
		dbus_message_iter_get_basic(&iter, &file_name);
		dbus_message_iter_next(&iter);
		dbus_message_iter_recurse(&iter, &sub_iter);
		no = dbus_message_iter_get_array_len(&sub_iter);
		dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);
		
		strcat(file_name, "_1");
		fp = fopen(file_name, "w+");
		if(!fp) 
		{
			printf("Failed to open file %s", file_name);
			getchar();
		}
		
		fwrite(array, sizeof(unsigned char), no, fp);
		if(fp)
			fclose(fp);
	}

void called_sign_test(DBusMessage* msg, DBusConnection* connection)
{
	DBusError error;
	const char* signature;
	const char* msg_sign;
	const char* msg_sign1;
	DBusSignatureIter sign_iter;
	DBusSignatureIter sub_sign_iter;
	DBusSignatureIter sub_sign_iter1;
	DBusMessageIter iter;
	DBusMessage* reply;
	int type;
	int sub_type;
	const char* sub_signature;
	
	dbus_error_init(&error);
	
	dbus_message_iter_init(msg, &iter);
	msg_sign = dbus_message_iter_get_signature(&iter);
	dbus_message_iter_next(&iter);
	dbus_message_iter_next(&iter);
	msg_sign1 = dbus_message_iter_get_signature(&iter);
	
	signature = dbus_message_get_signature(msg);
	dbus_signature_iter_init(&sign_iter, signature);
	if(dbus_signature_validate_single(signature, &error))
	{
		exit(1);
	}
	do{
		type = dbus_signature_iter_get_current_type(&sign_iter);
		switch(type)
		{
		case DBUS_TYPE_ARRAY:
			dbus_signature_iter_recurse(&sign_iter, &sub_sign_iter1);
			sub_type = dbus_signature_iter_get_element_type(&sign_iter);
			break;
		case DBUS_TYPE_STRUCT:
			dbus_signature_iter_recurse(&sign_iter, &sub_sign_iter);
			sub_signature = dbus_signature_iter_get_signature(&sign_iter); 
			dbus_error_init(&error);
			if(!dbus_signature_validate_single(sub_signature, &error))
			{
				exit(1);
			}
			break;
		}
	}while(dbus_signature_iter_next(&sign_iter));
	
	reply = dbus_message_new_method_return(msg);
	dbus_message_append_args(reply, DBUS_TYPE_SIGNATURE, &signature, DBUS_TYPE_SIGNATURE, &sub_signature, DBUS_TYPE_INT32, &sub_type, DBUS_TYPE_SIGNATURE, &msg_sign, DBUS_TYPE_SIGNATURE, &msg_sign1, DBUS_TYPE_INVALID);
	dbus_connection_send(connection, reply, NULL);
	dbus_connection_flush(connection);
	
	dbus_free((void*)msg_sign);
	dbus_free((void*)msg_sign1);
	dbus_message_unref(reply);
}

void called_file_send_whole(DBusMessage* msg, DBusConnection* connection)
	{
		DBusMessageIter iter;
		DBusMessageIter sub_iter;
		int no; 
		unsigned char* array;
		FILE* fp=NULL;
		DBusMessage* reply;
		
		reply = dbus_message_new_method_return(msg);
		dbus_connection_send(connection, reply, NULL);
		dbus_connection_flush(connection);
		
		dbus_message_iter_init(msg, &iter);
		dbus_message_iter_recurse(&iter, &sub_iter);
		no = dbus_message_iter_get_array_len(&sub_iter);
		dbus_message_iter_get_fixed_array(&sub_iter, &array, &no);
		
		fp = fopen("c:\\data\\Images\\Pictures\\test.mp3", "a+"); 
		if(!fp) 
		{
			printf("Failed to open file");
			getchar();
		}
		
		fwrite(array, sizeof(unsigned char), no, fp);
		
		if(fp)
			fclose(fp);
		
		dbus_message_unref(reply);
	}

int main()
{
	DBusError error;
	DBusError error1;
	DBusConnection* connection;
	DBusMessage* msg;
	DBusObjectPathVTable vtable = 
	{
		NULL,NULL,NULL
	}; 
	
	dbus_error_init(&error);
	dbus_error_init(&error1);

	connection = dbus_bus_get(DBUS_BUS_SESSION, &error);
	
	if(dbus_error_is_set(&error))
	{
		fprintf(stdout, "Error Occured :: %s", error.name);
		return 1;
	}
	

	
	if(dbus_connection_register_object_path (connection, "/Test/Method/Object", &vtable, NULL))
	{
		fprintf(stdout, "Object Path registered.");
	}
	else
	{
		fprintf(stdout, "Object Path not able to register.");
		return 1;
	}
 


	if(dbus_bus_request_name (connection, TEST_BUS_NAME_TEMP, DBUS_NAME_FLAG_ALLOW_REPLACEMENT, &error1) == -1)
	{
		fprintf(stdout, "Not able to request name.");
	}
	else
	{
		fprintf(stdout, "Name Request Successful");
	}
	
	while(TRUE)
	{	
		dbus_connection_read_write(connection, 0);
		
		msg = dbus_connection_pop_message(connection);
			
		if(msg == NULL)
		{
			sleep(1);
			continue;
		}
		     
		fprintf(stdout, "Message Detected");
		
		if(DBUS_MESSAGE_TYPE_SIGNAL == dbus_message_get_type(msg))
		{
			fprintf(stdout, "Message is Signal.");
		}
		
		if(DBUS_MESSAGE_TYPE_METHOD_CALL == dbus_message_get_type(msg))
		{
			fprintf(stdout, "Message is Method call.");
		}
		
				
		if(dbus_message_is_method_call(msg, "test.Method.Call", "method"))
			{
			called_method(msg, connection);
			break;
			} 
		
		if(dbus_message_is_method_call(msg, "test.Method.Call", "variable_args_method"))
			{
			
			called_variable_args_method(msg, connection);
			break;
			} 
		 
		if(dbus_message_is_method_call(msg, "test.Method.Call", "simple"))
			{
			
			called_simple(msg, connection);
	//		break;
			}
		if(dbus_message_is_method_call(msg, "test.Method.Call", "file_send"))
			{
			
			called_file_send(msg, connection);
	//		break; 
			} 
		if(dbus_message_is_method_call(msg, "test.Method.Call", "sign_test"))
			{
			
			called_sign_test(msg, connection);
			break; 
			} 
		if(dbus_message_is_method_call(msg, "test.Method.Call", "file_send_whole"))
			{
			
			called_file_send_whole(msg, connection);
			break; 
			}
		
		if(dbus_message_is_method_call(msg, "test.Method.Call", "file_send_time"))
			{
			
			called_file_send_time(msg, connection);
	//		break;
			}
		
	dbus_message_unref(msg);	
		
	}
	
	dbus_message_unref(msg);
	dbus_bus_release_name(connection,TEST_BUS_NAME_TEMP,&error1);
	dbus_connection_unregister_object_path(connection,"/Test/Method/Object");

	dbus_connection_unref(connection);	

	return 0;
}