/*
    This file is part of libmicrospdy
    Copyright Copyright (C) 2012 Andrey Uzunov

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/**
 * @file applicationlayer.c
 * @brief  SPDY application or HTTP layer
 * @author Andrey Uzunov
 */
 
#include "platform.h"
#include "applicationlayer.h"
#include "alstructures.h"
#include "structures.h"
#include "internal.h"
#include "daemon.h"
#include "session.h"


void
spdy_callback_response_done(void *cls,
						struct SPDY_Response *response,
						struct SPDY_Request *request,
						enum SPDY_RESPONSE_RESULT status,
						bool streamopened)
{
	(void)cls;
	(void)status;
	(void)streamopened;
  
	SPDY_destroy_request(request);
	SPDY_destroy_response(response);
}


/**
 * Callback called when new stream is created. It extracts the info from
 * the stream to create (HTTP) request object and pass it to the client.
 *
 * @param cls
 * @param stream the new SPDY stream
 * @return SPDY_YES on success, SPDY_NO on memomry error
 */
static int
spdy_handler_new_stream (void *cls,
						struct SPDYF_Stream * stream)
{
	(void)cls;
	unsigned int i;
	char *method = NULL;
	char *path = NULL;
	char *version = NULL;
	char *host = NULL;
	char *scheme = NULL;
	struct SPDY_Request * request = NULL;
	struct SPDY_NameValue * headers = NULL;
	struct SPDY_NameValue * iterator = stream->headers;
	struct SPDY_Daemon *daemon;
	
	daemon = stream->session->daemon;
	
	//if the user doesn't care, ignore it
	if(NULL == daemon->new_request_cb)
		return SPDY_YES;
	
	if(NULL == (headers=SPDY_name_value_create()))
		goto free_and_fail;
	
	if(NULL==(request = malloc(sizeof(struct SPDY_Request))))
		goto free_and_fail;
	
	memset(request, 0, sizeof(struct SPDY_Request));
	request->stream = stream;
	
	/* extract the mandatory fields from stream->headers' structure
	 * to pass them to the client */
	while(iterator != NULL)
	{
		if(strcmp(":method",iterator->name) == 0)
		{
			if(1 != iterator->num_values)
				break;
			method = iterator->value[0];
		}
		else if(strcmp(":path",iterator->name) == 0)
		{
			if(1 != iterator->num_values)
				break;
			path = iterator->value[0];
		}
		else if(strcmp(":version",iterator->name) == 0)
		{
			if(1 != iterator->num_values)
				break;
			version = iterator->value[0];
		}
		else if(strcmp(":host",iterator->name) == 0)
		{
			//TODO can it have more values?
			if(1 != iterator->num_values)
				break;
			host = iterator->value[0];
		}
		else if(strcmp(":scheme",iterator->name) == 0)
		{
			if(1 != iterator->num_values)
				break;
			scheme = iterator->value[0];
		}
		else
			for(i=0; i<iterator->num_values; ++i)
				if (SPDY_YES != SPDY_name_value_add(headers,iterator->name,iterator->value[i]))
        {
          SPDY_destroy_request(request);
					goto free_and_fail;
        }
		
		iterator = iterator->next;
	}
	
	request->method=method;
  request->path=path;
  request->version=version;
  request->host=host;
  request->scheme=scheme;
  request->headers=headers;
	
	//check request validity, all these fields are mandatory for a request
	if(NULL == method || strlen(method) == 0
		|| NULL == path || strlen(path) == 0
		|| NULL == version || strlen(version) == 0
		|| NULL == host || strlen(host) == 0
		|| NULL == scheme || strlen(scheme) == 0
		)
	{
		//TODO HTTP 400 Bad Request must be answered
		
		SPDYF_DEBUG("Bad request");
		
		SPDY_destroy_request(request);
		
		return SPDY_YES;
	}
	
	//call client's callback function to notify
	daemon->new_request_cb(daemon->cls,
						request,
						stream->priority,
                        method,
                        path,
                        version,
                        host,
                        scheme,
						headers,
            !stream->is_in_closed);
            
  stream->cls = request;

	return SPDY_YES;

	//for GOTO
	free_and_fail:
	
	SPDY_name_value_destroy(headers);
	return SPDY_NO;
}


/**
 * TODO
 */
static int
spdy_handler_new_data (void * cls,
					 struct SPDYF_Stream *stream,
					 const void * buf,
					 size_t size,
					 bool more)
{
  return stream->session->daemon->received_data_cb(cls, stream->cls, buf, size, more);
}


/**
 * Callback to be called when the response queue object was handled and 
 * the data was already sent or discarded. 
 *
 * @param cls
 * @param response_queue the object which is being handled
 * @param status shows if actually the response was sent or it was
 * 			discarded by the lib for any reason (e.g., closing session,
 * 			closing stream, stopping daemon, etc.). It is possible that
 * 			status indicates an error but parts of the response headers
 * 			and/or body (in one
 * 			or several frames) were already sent to the client.
 */
static void
spdy_handler_response_queue_result(void * cls,
								struct SPDYF_Response_Queue *response_queue,
								enum SPDY_RESPONSE_RESULT status)
{
	int streamopened;
	struct SPDY_Request *request = (struct SPDY_Request *)cls;
	
	SPDYF_ASSERT( ( (NULL == response_queue->data_frame) &&
			(NULL != response_queue->control_frame) ) ||
		      ( (NULL != response_queue->data_frame) &&
			(NULL == response_queue->control_frame) ),
		     "response queue must have either control frame or data frame");
	
	streamopened = !response_queue->stream->is_out_closed;
	
	response_queue->rrcb(response_queue->rrcb_cls, response_queue->response, request, status, streamopened);
}


int
(SPDY_init) (enum SPDY_IO_SUBSYSTEM io_subsystem, ...)
{
	SPDYF_ASSERT(SPDYF_BUFFER_SIZE >= SPDY_MAX_SUPPORTED_FRAME_SIZE,
		"Buffer size is less than max supported frame size!");
	SPDYF_ASSERT(SPDY_MAX_SUPPORTED_FRAME_SIZE >= 32,
		"Max supported frame size must be bigger than the minimal value!");
	SPDYF_ASSERT(SPDY_IO_SUBSYSTEM_NONE == spdyf_io_initialized,
		"SPDY_init must be called only once per program or after SPDY_deinit");
    
  if(SPDY_IO_SUBSYSTEM_OPENSSL & io_subsystem)
  {
    SPDYF_openssl_global_init();
    spdyf_io_initialized |= SPDY_IO_SUBSYSTEM_OPENSSL;
  }
  else if(SPDY_IO_SUBSYSTEM_RAW & io_subsystem)
  {
    SPDYF_raw_global_init();
    spdyf_io_initialized |= SPDY_IO_SUBSYSTEM_RAW;
  }
  
	SPDYF_ASSERT(SPDY_IO_SUBSYSTEM_NONE != spdyf_io_initialized,
		"SPDY_init could not find even one IO subsystem");
    
	return SPDY_YES;
}


void
SPDY_deinit ()
{
	SPDYF_ASSERT(SPDY_IO_SUBSYSTEM_NONE != spdyf_io_initialized,
		"SPDY_init has not been called!");
    
  if(SPDY_IO_SUBSYSTEM_OPENSSL & spdyf_io_initialized)
    SPDYF_openssl_global_deinit();
  else if(SPDY_IO_SUBSYSTEM_RAW & spdyf_io_initialized)
    SPDYF_raw_global_deinit();
  
  spdyf_io_initialized = SPDY_IO_SUBSYSTEM_NONE;
}


void 
SPDY_run (struct SPDY_Daemon *daemon)
{
	if(NULL == daemon)
	{
		SPDYF_DEBUG("daemon is NULL");
		return;
	}
	
	SPDYF_run(daemon);
}


int
SPDY_get_timeout (struct SPDY_Daemon *daemon, 
		     unsigned long long *timeout)
{
	if(NULL == daemon)
	{
		SPDYF_DEBUG("daemon is NULL");
		return SPDY_INPUT_ERROR;
	}
	
	return SPDYF_get_timeout(daemon,timeout);
}


int
SPDY_get_fdset (struct SPDY_Daemon *daemon,
				fd_set *read_fd_set,
				fd_set *write_fd_set, 
				fd_set *except_fd_set)
{
	if(NULL == daemon
		|| NULL == read_fd_set
		|| NULL == write_fd_set
		|| NULL == except_fd_set)
	{
		SPDYF_DEBUG("a parameter is NULL");
		return SPDY_INPUT_ERROR;
	}
	
	return SPDYF_get_fdset(daemon,
				read_fd_set,
				write_fd_set, 
				except_fd_set,
				false);
}


struct SPDY_Daemon *
SPDY_start_daemon (uint16_t port,
				const char *certfile,
				const char *keyfile,
		     SPDY_NewSessionCallback nscb,
		     SPDY_SessionClosedCallback sccb,
		     SPDY_NewRequestCallback nrcb,
		     SPDY_NewDataCallback npdcb,
		     void * cls,
		     ...)
{
	struct SPDY_Daemon *daemon;
	va_list valist;
	
	if(SPDY_IO_SUBSYSTEM_NONE == spdyf_io_initialized)
	{
		SPDYF_DEBUG("library not initialized");
		return NULL;
	}
  /*
   * for now make this checks in framing layer
	if(NULL == certfile)
	{
		SPDYF_DEBUG("certfile is NULL");
		return NULL;
	}
	if(NULL == keyfile)
	{
		SPDYF_DEBUG("keyfile is NULL");
		return NULL;
	}
  */
	
	va_start(valist, cls);
	daemon = SPDYF_start_daemon_va ( port,
				certfile,
				keyfile,
		      nscb,
		      sccb,
		      nrcb,
		      npdcb,
		      &spdy_handler_new_stream,
		      &spdy_handler_new_data,
		      cls,
		      NULL,
		      valist
		     );
	va_end(valist);
	
	return daemon;
}


void 
SPDY_stop_daemon (struct SPDY_Daemon *daemon)
{	
	if(NULL == daemon)
	{
		SPDYF_DEBUG("daemon is NULL");
		return;
	}

	SPDYF_stop_daemon(daemon);
}


struct SPDY_Response *
SPDY_build_response(int status,
					const char * statustext,
					const char * version,
					struct SPDY_NameValue * headers,
					const void * data,
					size_t size)
{
	struct SPDY_Response *response = NULL;
	struct SPDY_NameValue ** all_headers = NULL; //TODO maybe array in stack is enough
	char *fullstatus = NULL;
	int ret;
	int num_hdr_containers = 1;
	
	if(NULL == version)
	{
		SPDYF_DEBUG("version is NULL");
		return NULL;
	}
	
	if(NULL == (response = malloc(sizeof(struct SPDY_Response))))
		goto free_and_fail;
	memset(response, 0, sizeof(struct SPDY_Response));
	
	if(NULL != headers && !SPDYF_name_value_is_empty(headers))
		num_hdr_containers = 2;
	
	if(NULL == (all_headers = malloc(num_hdr_containers * sizeof(struct SPDY_NameValue *))))
		goto free_and_fail;
	memset(all_headers, 0, num_hdr_containers * sizeof(struct SPDY_NameValue *));
	
	if(2 == num_hdr_containers)
		all_headers[1] = headers;
	
	if(NULL == (all_headers[0] = SPDY_name_value_create()))
		goto free_and_fail;
	
	if(NULL == statustext)
		ret = asprintf(&fullstatus, "%i", status);
	else
		ret = asprintf(&fullstatus, "%i %s", status, statustext); 
	if(-1 == ret)
		goto free_and_fail;
		
	if(SPDY_YES != SPDY_name_value_add(all_headers[0], ":status", fullstatus))
		goto free_and_fail;
		
	free(fullstatus);
	fullstatus = NULL;
	
	if(SPDY_YES != SPDY_name_value_add(all_headers[0], ":version", version))
		goto free_and_fail;
	
	if(0 >= (response->headers_size = SPDYF_name_value_to_stream(all_headers,
												num_hdr_containers,
												&(response->headers))))
		goto free_and_fail;
		
	SPDY_name_value_destroy(all_headers[0]);
	free(all_headers);
  all_headers = NULL;
	
	if(size > 0)
	{
		//copy the data to the response object
		if(NULL == (response->data = malloc(size)))
		{
			free(response->headers);
			goto free_and_fail;
		}
		memcpy(response->data, data, size);
		response->data_size = size;
	}
	
	return response;
	
	//for GOTO
	free_and_fail:
	
	free(fullstatus);
	if(NULL != all_headers)
		SPDY_name_value_destroy(all_headers[0]);
	free(all_headers);
	free(response);
	
	return NULL;
}


struct SPDY_Response *
SPDY_build_response_with_callback(int status,
					const char * statustext,
					const char * version,
					struct SPDY_NameValue * headers,
					SPDY_ResponseCallback rcb,
					void *rcb_cls,
					uint32_t block_size)
{
	struct SPDY_Response *response;
	
	if(NULL == rcb)
	{
		SPDYF_DEBUG("rcb is NULL");
		return NULL;
	}
	if(block_size > SPDY_MAX_SUPPORTED_FRAME_SIZE)
	{
		SPDYF_DEBUG("block_size is wrong");
		return NULL;
	}
	
	if(0 == block_size)
		block_size = SPDY_MAX_SUPPORTED_FRAME_SIZE;
	
	response = SPDY_build_response(status,
					statustext,
					version,
					headers,
					NULL,
					0);
	
	if(NULL == response)
	{
		return NULL;
	}
			
	response->rcb = rcb;
	response->rcb_cls = rcb_cls;
	response->rcb_block_size = block_size;
	
	return response;
}


int
SPDY_queue_response (struct SPDY_Request * request,
					struct SPDY_Response *response,
					bool closestream,
					bool consider_priority,
					SPDY_ResponseResultCallback rrcb,
					void * rrcb_cls)
{
	struct SPDYF_Response_Queue *headers_to_queue;
	struct SPDYF_Response_Queue *body_to_queue;
	SPDYF_ResponseQueueResultCallback frqcb = NULL;
	void *frqcb_cls = NULL;
	int int_consider_priority = consider_priority ? SPDY_YES : SPDY_NO;
	
	if(NULL == request)
	{
		SPDYF_DEBUG("request is NULL");
		return SPDY_INPUT_ERROR;
	}
	if(NULL == response)
	{
		SPDYF_DEBUG("request is NULL");
		return SPDY_INPUT_ERROR;
	}
	
	if(request->stream->is_out_closed
		|| SPDY_SESSION_STATUS_CLOSING == request->stream->session->status)
		return SPDY_NO;
	
	if(NULL != rrcb)
	{
		frqcb_cls = request;
		frqcb = &spdy_handler_response_queue_result;
	}
	
	if(response->data_size > 0)
	{	
		//SYN_REPLY and DATA will be queued
		
		if(NULL == (headers_to_queue = SPDYF_response_queue_create(false,
							response->headers,
							response->headers_size,
							response,
							request->stream,
							false,
							NULL,
							NULL,
							NULL,
							NULL)))
		{
			return SPDY_NO;
		}
		
		if(NULL == (body_to_queue = SPDYF_response_queue_create(true,
							response->data,
							response->data_size,
							response,
							request->stream,
							closestream,
							frqcb,
							frqcb_cls,
							rrcb,
							rrcb_cls)))
		{
			SPDYF_response_queue_destroy(headers_to_queue);
			return SPDY_NO;
		}
							
		SPDYF_queue_response (headers_to_queue,
							request->stream->session,
							int_consider_priority);
							
		SPDYF_queue_response (body_to_queue,
							request->stream->session,
							int_consider_priority);
	}
	else if(NULL == response->rcb)
	{
		//no "body" will be queued, e.g. HTTP 404 without body
		
		if(NULL == (headers_to_queue = SPDYF_response_queue_create(false,
							response->headers,
							response->headers_size,
							response,
							request->stream,
							closestream,
							frqcb,
							frqcb_cls,
							rrcb,
							rrcb_cls)))
		{
			return SPDY_NO;
		}
							
		SPDYF_queue_response (headers_to_queue,
							request->stream->session,
							int_consider_priority);
	}
	else
	{
		//response with callbacks
		
		if(NULL == (headers_to_queue = SPDYF_response_queue_create(false,
							response->headers,
							response->headers_size,
							response,
							request->stream,
							false,
							NULL,
							NULL,
							NULL,
							NULL)))
		{
			return SPDY_NO;
		}
		
		if(NULL == (body_to_queue = SPDYF_response_queue_create(true,
							response->data,
							response->data_size,
							response,
							request->stream,
							closestream,
							frqcb,
							frqcb_cls,
							rrcb,
							rrcb_cls)))
		{
			SPDYF_response_queue_destroy(headers_to_queue);
			return SPDY_NO;
		}
							
		SPDYF_queue_response (headers_to_queue,
							request->stream->session,
							int_consider_priority);
							
		SPDYF_queue_response (body_to_queue,
							request->stream->session,
							int_consider_priority);
	}
		
	return SPDY_YES;
}


socklen_t
SPDY_get_remote_addr(struct SPDY_Session * session,
					 struct sockaddr ** addr)
{
	if(NULL == session)
	{
		SPDYF_DEBUG("session is NULL");
		return 0;
	}
	
	*addr = session->addr;
	
	return session->addr_len;
}


struct SPDY_Session *
SPDY_get_session_for_request(const struct SPDY_Request * request)
{
	if(NULL == request)
	{
		SPDYF_DEBUG("request is NULL");
		return NULL;
	}
	
	return request->stream->session;
}


void *
SPDY_get_cls_from_session(struct SPDY_Session * session)
{
	if(NULL == session)
	{
		SPDYF_DEBUG("session is NULL");
		return NULL;
	}
	
	return session->user_cls;
}


void
SPDY_set_cls_to_session(struct SPDY_Session * session,
							void * cls)
{
	if(NULL == session)
	{
		SPDYF_DEBUG("session is NULL");
		return;
	}
	
	session->user_cls = cls;
}


void *
SPDY_get_cls_from_request(struct SPDY_Request * request)
{
	if(NULL == request)
	{
		SPDYF_DEBUG("request is NULL");
		return NULL;
	}
	
	return request->user_cls;
}


void
SPDY_set_cls_to_request(struct SPDY_Request * request,
							void * cls)
{
	if(NULL == request)
	{
		SPDYF_DEBUG("request is NULL");
		return;
	}
	
	request->user_cls = cls;
}