/*
 * COMP 321 Project 6: Web Proxy
 *
 * This program implements a multithreaded HTTP proxy.
 *
 * Implements a prethreaded concurrent proxy that:
 * - Accepts HTTP GET requests from clients
 * - Forwards requests to end servers (rewriting URI to path only)
 * - Forwards responses back to clients
 * - Logs completed transactions to proxy.log
 * - Uses bounded buffer with mutex/condvar for concurrency
 */

#include <assert.h>

#include "csapp.h"

static void	client_error(int fd, const char *cause, int err_num,
		    const char *short_msg, const char *long_msg);
static char    *create_log_entry(const struct sockaddr_in *sockaddr,
		    const char *uri, int size);
static int	parse_uri(const char *uri, char **hostnamep, char **portp,
		    char **pathnamep);

/*
 * Prethreading constants.
 */
#define NTHREADS  8
#define SBUFSIZE  64

/*
 * Bounded buffer for connection file descriptors.
 * Synchronized with Pthread mutex and condition variables (no semaphores).
 */
typedef struct {
	int *buf;               /* Buffer array */
	int n;                  /* Maximum number of slots */
	int front;              /* Index for next removal */
	int rear;               /* Index for next insertion */
	pthread_mutex_t mutex;  /* Protects accesses to buf */
	pthread_cond_t slots;   /* Signaled when a slot becomes available */
	pthread_cond_t items;   /* Signaled when an item becomes available */
} sbuf_t;

/* Global variables. */
static sbuf_t sbuf;               /* Shared buffer of connected descriptors */
static FILE *log_fp;              /* Log file pointer (opened once) */
static pthread_mutex_t log_mutex; /* Protects log file writes */

/*
 * Requires:
 *   sp points to a valid sbuf_t, n > 0.
 *
 * Effects:
 *   Initializes the bounded buffer with capacity n.
 */
static void
sbuf_init(sbuf_t *sp, int n)
{

	sp->buf = Calloc(n, sizeof(int));
	sp->n = n;
	sp->front = sp->rear = 0;
	pthread_mutex_init(&sp->mutex, NULL);
	pthread_cond_init(&sp->slots, NULL);
	pthread_cond_init(&sp->items, NULL);
}

/*
 * Requires:
 *   sp points to an initialized sbuf_t.
 *
 * Effects:
 *   Inserts item into the buffer, blocking if the buffer is full.
 */
static void
sbuf_insert(sbuf_t *sp, int item)
{

	pthread_mutex_lock(&sp->mutex);
	while ((sp->rear - sp->front) >= sp->n)
		pthread_cond_wait(&sp->slots, &sp->mutex);
	sp->buf[(sp->rear++) % sp->n] = item;
	pthread_cond_signal(&sp->items);
	pthread_mutex_unlock(&sp->mutex);
}

/*
 * Requires:
 *   sp points to an initialized sbuf_t.
 *
 * Effects:
 *   Removes and returns an item from the buffer, blocking if empty.
 */
static int
sbuf_remove(sbuf_t *sp)
{
	int item;

	pthread_mutex_lock(&sp->mutex);
	while (sp->rear == sp->front)
		pthread_cond_wait(&sp->items, &sp->mutex);
	item = sp->buf[(sp->front++) % sp->n];
	pthread_cond_signal(&sp->slots);
	pthread_mutex_unlock(&sp->mutex);
	return (item);
}

/*
 * Requires:
 *   rp points to an initialized rio_t.
 *
 * Effects:
 *   Reads a complete line from the rio buffer, handling lines longer
 *   than MAXLINE by dynamically allocating memory.  Returns a
 *   dynamically allocated string, or NULL on error/EOF with no data.
 *   The caller must free the returned string.
 */
static char *
read_full_line(rio_t *rp)
{
	char buf[MAXLINE];
	char *line = NULL;
	size_t total_len = 0;
	ssize_t n;

	for (;;) {
		n = rio_readlineb(rp, buf, MAXLINE);
		if (n <= 0) {
			if (total_len == 0) {
				free(line);
				return (NULL);
			}
			break;
		}
		char *new_line = realloc(line, total_len + n + 1);
		if (new_line == NULL) {
			free(line);
			return (NULL);
		}
		line = new_line;
		memcpy(line + total_len, buf, n);
		total_len += n;
		line[total_len] = '\0';
		if (buf[n - 1] == '\n')
			break;
	}
	return (line);
}

/*
 * Requires:
 *   connfd is an open socket connected to a client.
 *
 * Effects:
 *   Handles a single HTTP GET request: reads the request from the client,
 *   forwards it to the end server, forwards the response back to the
 *   client, and logs the completed transaction.  Closes connfd and any
 *   server connection when done.  Frees all allocated memory.
 */
static void
handle_request(int connfd)
{
	rio_t rio_client;
	char *hostname = NULL, *port = NULL, *pathname = NULL;
	char *request_line = NULL, *uri = NULL;
	char *request = NULL;
	int serverfd = -1;
	char buf[MAXLINE];
	struct sockaddr_in clientaddr;
	socklen_t clientlen;

	/* Get client address for logging. */
	clientlen = sizeof(clientaddr);
	if (getpeername(connfd, (SA *)&clientaddr, &clientlen) < 0) {
		close(connfd);
		return;
	}

	/* Initialize RIO for client socket. */
	rio_readinitb(&rio_client, connfd);

	/* Read the request line (may be longer than MAXLINE). */
	request_line = read_full_line(&rio_client);
	if (request_line == NULL) {
		close(connfd);
		return;
	}

	/*
	 * Parse the request line: METHOD URI VERSION
	 */
	char *p = request_line;

	/* Skip leading whitespace. */
	while (*p && isspace((unsigned char)*p))
		p++;

	/* Extract method. */
	char *method_start = p;
	while (*p && !isspace((unsigned char)*p))
		p++;
	if (*p == '\0') {
		client_error(connfd, request_line, 400, "Bad Request",
		    "Malformed request line");
		free(request_line);
		close(connfd);
		return;
	}
	*p++ = '\0';

	/* Skip spaces between method and URI. */
	while (*p == ' ' || *p == '\t')
		p++;

	/* Extract URI. */
	char *uri_start = p;
	while (*p && !isspace((unsigned char)*p))
		p++;
	if (uri_start == p) {
		client_error(connfd, method_start, 400, "Bad Request",
		    "Missing URI");
		free(request_line);
		close(connfd);
		return;
	}
	*p = '\0';

	/* Make a copy of the URI for logging. */
	uri = strdup(uri_start);
	if (uri == NULL) {
		free(request_line);
		close(connfd);
		return;
	}

	/* Only support GET. */
	if (strcasecmp(method_start, "GET") != 0) {
		client_error(connfd, method_start, 501, "Not Implemented",
		    "Proxy only supports GET");
		free(uri);
		free(request_line);
		close(connfd);
		return;
	}

	/* Parse the URI to extract hostname, port, pathname. */
	if (parse_uri(uri, &hostname, &port, &pathname) < 0) {
		client_error(connfd, uri, 400, "Bad Request",
		    "Could not parse URI");
		free(uri);
		free(request_line);
		close(connfd);
		return;
	}
	free(request_line);
	request_line = NULL;

	/*
	 * Build the request to forward to the end server.
	 */
	size_t req_cap = strlen(pathname) + strlen(hostname) +
	    strlen(port) + MAXBUF;
	size_t req_len = 0;
	request = malloc(req_cap);
	if (request == NULL)
		goto cleanup_no_server;

	/* Request line: GET <path> HTTP/1.0 */
	int n = snprintf(request, req_cap, "GET %s HTTP/1.0\r\n", pathname);
	req_len = n;

	/* Host header. */
	if (strcmp(port, "80") == 0)
		n = snprintf(request + req_len, req_cap - req_len,
		    "Host: %s\r\n", hostname);
	else
		n = snprintf(request + req_len, req_cap - req_len,
		    "Host: %s:%s\r\n", hostname, port);
	req_len += n;

	/* Connection: close header. */
	n = snprintf(request + req_len, req_cap - req_len,
	    "Connection: close\r\n");
	req_len += n;

	/* Read and forward remaining client headers. */
	char *hdr_line;
	while ((hdr_line = read_full_line(&rio_client)) != NULL) {
		/* Empty line terminates headers. */
		if (strcmp(hdr_line, "\r\n") == 0 ||
		    strcmp(hdr_line, "\n") == 0) {
			free(hdr_line);
			break;
		}

		/* Strip Connection, Keep-Alive, Proxy-Connection, Host. */
		if (strncasecmp(hdr_line, "Connection:", 11) == 0 ||
		    strncasecmp(hdr_line, "Keep-Alive:", 11) == 0 ||
		    strncasecmp(hdr_line, "Proxy-Connection:", 17) == 0 ||
		    strncasecmp(hdr_line, "Host:", 5) == 0) {
			free(hdr_line);
			continue;
		}

		/* Grow buffer if needed. */
		size_t hdr_len = strlen(hdr_line);
		while (req_len + hdr_len + 3 > req_cap) {
			req_cap *= 2;
			char *new_req = realloc(request, req_cap);
			if (new_req == NULL) {
				free(hdr_line);
				free(request);
				request = NULL;
				goto cleanup_no_server;
			}
			request = new_req;
		}
		memcpy(request + req_len, hdr_line, hdr_len);
		req_len += hdr_len;
		free(hdr_line);
	}

	/* Terminate headers with blank line. */
	memcpy(request + req_len, "\r\n", 2);
	req_len += 2;
	request[req_len] = '\0';

	/* Connect to end server. */
	serverfd = open_clientfd(hostname, port);
	if (serverfd < 0) {
		client_error(connfd, hostname, 502, "Bad Gateway",
		    "Could not connect to end server");
		free(request);
		request = NULL;
		goto cleanup_no_server;
	}

	/* Send request to end server. */
	if (rio_writen(serverfd, request, req_len) < 0) {
		free(request);
		request = NULL;
		goto cleanup;
	}
	free(request);
	request = NULL;

	/*
	 * Forward response from end server to client, counting bytes.
	 * Use read() instead of rio_readn to stream data immediately
	 * without buffering up to MAXLINE bytes.
	 */
	int total_size = 0;
	ssize_t nread;
	int write_failed = 0;
	while (1) {
		nread = read(serverfd, buf, MAXLINE);
		if (nread > 0) {
			total_size += nread;
			if (!write_failed) {
				if (rio_writen(connfd, buf, nread) < 0)
					write_failed = 1;
			}
		} else if (nread == 0) {
			break; /* EOF */
		} else {
			if (errno == EINTR)
				continue;
			break; /* Error */
		}
	}

	/* Log the completed transaction. */
	if (total_size > 0) {
		char *log_entry = create_log_entry(&clientaddr, uri,
		    total_size);
		pthread_mutex_lock(&log_mutex);
		fprintf(log_fp, "%s\n", log_entry);
		fflush(log_fp);
		pthread_mutex_unlock(&log_mutex);
		free(log_entry);
	}

cleanup:
	close(serverfd);
cleanup_no_server:
	free(uri);
	free(hostname);
	free(port);
	free(pathname);
	close(connfd);
}

/*
 * Requires:
 *   vargp is unused.
 *
 * Effects:
 *   Worker thread routine.  Detaches itself, then repeatedly removes
 *   a connected descriptor from the shared buffer and handles the request.
 */
static void *
thread(void *vargp)
{
	int connfd;

	(void)vargp;
	Pthread_detach(Pthread_self());
	while (1) {
		connfd = sbuf_remove(&sbuf);
		handle_request(connfd);
	}
	return (NULL);
}

/*
 * Requires:
 *   argc == 2, argv[1] is a valid port number string.
 *
 * Effects:
 *   Starts the proxy server: ignores SIGPIPE, opens the log file,
 *   initializes the bounded buffer, creates worker threads, opens a
 *   listening socket, and accepts connections in a loop.
 */
int
main(int argc, char **argv)
{
	int listenfd, connfd;
	struct sockaddr_in clientaddr;
	socklen_t clientlen;
	pthread_t tid;
	int i;

	/* Check the arguments. */
	if (argc != 2) {
		fprintf(stderr, "Usage: %s <port number>\n", argv[0]);
		exit(0);
	}

	/* Ignore SIGPIPE to prevent crashing on broken connections. */
	Signal(SIGPIPE, SIG_IGN);

	/* Open log file once during initialization. */
	log_fp = Fopen("proxy.log", "a");

	/* Initialize log mutex. */
	pthread_mutex_init(&log_mutex, NULL);

	/* Initialize connection buffer. */
	sbuf_init(&sbuf, SBUFSIZE);

	/* Create worker threads. */
	for (i = 0; i < NTHREADS; i++)
		Pthread_create(&tid, NULL, thread, NULL);

	/* Open listening socket. */
	listenfd = open_listenfd(argv[1]);
	if (listenfd < 0) {
		fprintf(stderr, "open_listenfd error on port %s\n", argv[1]);
		exit(1);
	}

	/* Accept connections and dispatch to worker threads. */
	while (1) {
		clientlen = sizeof(clientaddr);
		connfd = accept(listenfd, (SA *)&clientaddr, &clientlen);
		if (connfd < 0) {
			if (errno == EINTR)
				continue;
			continue;
		}
		sbuf_insert(&sbuf, connfd);
	}

	/* Return success. */
	return (0);
}

/*
 * Requires:
 *   The parameter "uri" must point to a properly NUL-terminated string.
 *
 * Effects:
 *   Given a URI from an HTTP proxy GET request (i.e., a URL), extract the
 *   host name, port, and path name.  Create strings containing the host name,
 *   port, and path name, and return them through the parameters "hostnamep",
 *   "portp", "pathnamep", respectively.  (The caller must free the memory
 *   storing these strings.)  Return -1 if there are any problems and 0
 *   otherwise.
 */
static int
parse_uri(const char *uri, char **hostnamep, char **portp, char **pathnamep)
{
	const char *pathname_begin, *port_begin, *port_end;

	if (strncasecmp(uri, "http://", 7) != 0)
		return (-1);

	/* Extract the host name. */
	const char *host_begin = uri + 7;
	const char *host_end = strpbrk(host_begin, ":/ \r\n");
	if (host_end == NULL)
		host_end = host_begin + strlen(host_begin);
	int len = host_end - host_begin;
	char *hostname = Malloc(len + 1);
	strncpy(hostname, host_begin, len);
	hostname[len] = '\0';
	*hostnamep = hostname;

	/* Look for a port number.  If none is found, use port 80. */
	if (*host_end == ':') {
		port_begin = host_end + 1;
		port_end = strpbrk(port_begin, "/ \r\n");
		if (port_end == NULL)
			port_end = port_begin + strlen(port_begin);
		len = port_end - port_begin;
	} else {
		port_begin = "80";
		port_end = host_end;
		len = 2;
	}
	char *port = Malloc(len + 1);
	strncpy(port, port_begin, len);
	port[len] = '\0';
	*portp = port;

	/* Extract the path. */
	if (*port_end == '/') {
		pathname_begin = port_end;
		const char *pathname_end = strpbrk(pathname_begin, " \r\n");
		if (pathname_end == NULL)
			pathname_end = pathname_begin + strlen(pathname_begin);
		len = pathname_end - pathname_begin;
	} else {
		pathname_begin = "/";
		len = 1;
	}
	char *pathname = Malloc(len + 1);
	strncpy(pathname, pathname_begin, len);
	pathname[len] = '\0';
	*pathnamep = pathname;

	return (0);
}

/*
 * Requires:
 *   The parameter "sockaddr" must point to a valid sockaddr_in structure.  The
 *   parameter "uri" must point to a properly NUL-terminated string.
 *
 * Effects:
 *   Returns a string containing a properly formatted log entry.  This log
 *   entry is based upon the socket address of the requesting client
 *   ("sockaddr"), the URI from the request ("uri"), and the size in bytes of
 *   the response from the server ("size").
 */
static char *
create_log_entry(const struct sockaddr_in *sockaddr, const char *uri, int size)
{
	struct tm result;

	/*
	 * Create a large enough array of characters to store a log entry.
	 * Although the length of the URI can exceed MAXLINE, the combined
	 * lengths of the other fields and separators cannot.
	 */
	const size_t log_maxlen = MAXLINE + strlen(uri);
	char *const log_str = Malloc(log_maxlen + 1);

	/* Get a formatted time string. */
	time_t now = time(NULL);
	int log_strlen = strftime(log_str, MAXLINE, "%a %d %b %Y %H:%M:%S %Z: ",
	    localtime_r(&now, &result));

	/*
	 * Convert the IP address in network byte order to dotted decimal
	 * form.
	 */
	Inet_ntop(AF_INET, &sockaddr->sin_addr, &log_str[log_strlen],
	    INET_ADDRSTRLEN);
	log_strlen += strlen(&log_str[log_strlen]);

	/*
	 * Assert that the time and IP address fields occupy less than half of
	 * the space that is reserved for the non-URI fields.
	 */
	assert(log_strlen < MAXLINE / 2);

	/*
	 * Add the URI and response size onto the end of the log entry.
	 */
	snprintf(&log_str[log_strlen], log_maxlen - log_strlen, " %s %d", uri,
	    size);

	return (log_str);
}

/*
 * Requires:
 *   The parameter "fd" must be an open socket that is connected to the client.
 *   The parameters "cause", "short_msg", and "long_msg" must point to properly
 *   NUL-terminated strings that describe the reason why the HTTP transaction
 *   failed.  The string "short_msg" may not exceed 32 characters in length,
 *   and the string "long_msg" may not exceed 80 characters in length.
 *
 * Effects:
 *   Constructs an HTML page describing the reason why the HTTP transaction
 *   failed, and writes an HTTP/1.0 response containing that page as the
 *   content.  The cause appearing in the HTML page is truncated if the
 *   string "cause" exceeds 2048 characters in length.
 */
static void
client_error(int fd, const char *cause, int err_num, const char *short_msg,
    const char *long_msg)
{
	char body[MAXBUF], headers[MAXBUF], truncated_cause[2049];

	assert(strlen(short_msg) <= 32);
	assert(strlen(long_msg) <= 80);
	/* Ensure that "body" is much larger than "truncated_cause". */
	assert(sizeof(truncated_cause) < MAXBUF / 2);

	/*
	 * Create a truncated "cause" string so that the response body will not
	 * exceed MAXBUF.
	 */
	strncpy(truncated_cause, cause, sizeof(truncated_cause) - 1);
	truncated_cause[sizeof(truncated_cause) - 1] = '\0';

	/* Build the HTTP response body. */
	snprintf(body, MAXBUF,
	    "<html><title>Proxy Error</title><body bgcolor=""ffffff"">\r\n"
	    "%d: %s\r\n"
	    "<p>%s: %s\r\n"
	    "<hr><em>The COMP 321 Web proxy</em>\r\n",
	    err_num, short_msg, long_msg, truncated_cause);

	/* Build the HTTP response headers. */
	snprintf(headers, MAXBUF,
	    "HTTP/1.0 %d %s\r\n"
	    "Content-type: text/html\r\n"
	    "Content-length: %d\r\n"
	    "\r\n",
	    err_num, short_msg, (int)strlen(body));

	/* Write the HTTP response. */
	if (rio_writen(fd, headers, strlen(headers)) != -1)
		rio_writen(fd, body, strlen(body));
}

// Prevent "unused function" and "unused variable" warnings.
static const void *dummy_ref[] = { client_error, create_log_entry, dummy_ref,
    parse_uri };