#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "csapp.h"



void echo(int connfd);

void doit(int fd);
void read_requesthdrs(rio_t *rp);
int parse_uri(char *uri, char *filename, char *cgiargs);
void serve_static(int fd, char *filename, int filesize);
void get_filetype(char *filename, char *filetype);
void serve_dynamic(int fd, char *filename, char *cgiargs);
void clienterror(int fd, char *cause, char *errnum, char *shortmsg, char *longmsg);

int main(int argc, char **argv) 
{
    	int listenfd, connfd, port, clientlen;
    	struct sockaddr_in clientaddr;

    	/* Check command line args */
    	if (argc != 2) {
		fprintf(stderr, "usage: %s <port>\n", argv[0]);
		exit(1);
    	}
    	port = atoi(argv[1]);

    	listenfd = Open_listenfd(port);
    	while (1) {
		clientlen = sizeof(clientaddr);
		connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen); 
		doit(connfd);     
		Close(connfd);    
    	}
}
/* echo function - reads and echo text lines until client closes connection */
void echo(int connfd) 
{
    	size_t n; 
    	char buf[MAXLINE]; 
    	rio_t rio;

    	Rio_readinitb(&rio, connfd);
    	while((n = Rio_readlineb(&rio, buf, MAXLINE)) != 0) {
		printf("server received %d bytes\n", n);
		Rio_writen(connfd, buf, n);
    	}
}

/*
 * doit - handle one HTTP request/response transaction
 */
/* $begin doit */
void doit(int fd) 
{
    	int is_static;
    	struct stat sbuf;
    	char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE];
    	char filename[MAXLINE], cgiargs[MAXLINE];
    	rio_t rio;
  
    	/* Read request line and headers */
    	Rio_readinitb(&rio, fd);
    	Rio_readlineb(&rio, buf, MAXLINE);                   
    	sscanf(buf, "%s %s %s", method, uri, version);       
    	if (strcasecmp(method, "GET")) {                     
       		clienterror(fd, method, "501", "Not Implemented",
                "Tiny does not implement this method");
        	return;
    	}                                                    
    	read_requesthdrs(&rio);                              

    	/* Parse URI from GET request */
    	is_static = parse_uri(uri, filename, cgiargs);       
    	if (stat(filename, &sbuf) < 0) {                     
		clienterror(fd, filename, "404", "Not found",
		    "Tiny couldn't find this file");
		return;
    	}                                                    
    	if (is_static) { /* Serve static content */          
		if (!(S_ISREG(sbuf.st_mode)) || !(S_IRUSR & sbuf.st_mode)) {
	    		clienterror(fd, filename, "403", "Forbidden",
			"Tiny couldn't read the file");
	   	return;
		}
		serve_static(fd, filename, sbuf.st_size);  
    	}
    	else { /* Serve dynamic content */
		if (!(S_ISREG(sbuf.st_mode)) || !(S_IXUSR & sbuf.st_mode)) { 
	    		clienterror(fd, filename, "403", "Forbidden",
			"Tiny couldn't run the CGI program");
	    		return;
		}
		serve_dynamic(fd, filename, cgiargs);       
    	}
}
/* $end doit */

/*
 * read_requesthdrs - read and parse HTTP request headers
 */
/* $begin read_requesthdrs */
void read_requesthdrs(rio_t *rp) 
{
    	char buf[MAXLINE];

    	Rio_readlineb(rp, buf, MAXLINE);
    	while(strcmp(buf, "\r\n")) {          
		Rio_readlineb(rp, buf, MAXLINE);
		printf("%s", buf);
    	}
    	return;
}
/* $end read_requesthdrs */

/*
 * parse_uri - parse URI into filename and CGI args
 *             return 0 if dynamic content, 1 if static
 */
/* $begin parse_uri */
int parse_uri(char *uri, char *filename) 
{
    	char *ptr;
	char *hostname;
	char *port;
	char *temp = uri + 7;	
	
	printf("temp --> %s\n", temp);		
	
	ptr = strchar(temp, "/");
	if(ptr) {
		strcpy(ptr, "");
		printf("newtemp --> %s\n", temp);		
	}	
	else{

	}

	
}
/* $end parse_uri */

/*
 * serve_static - copy a file back to the client 
 */
/* $begin serve_static */
void serve_static(int fd, char *filename, int filesize) 
{
    	int srcfd;
    	char *srcp, filetype[MAXLINE], buf[MAXBUF];
 
    	/* Send response headers to client */
    	get_filetype(filename, filetype);       
    	sprintf(buf, "HTTP/1.0 200 OK\r\n");    
    	sprintf(buf, "%sServer: Tiny Web Server\r\n", buf);
    	sprintf(buf, "%sContent-length: %d\r\n", buf, filesize);
    	sprintf(buf, "%sContent-type: %s\r\n\r\n", buf, filetype);
    	Rio_writen(fd, buf, strlen(buf));       

    	/* Send response body to client */
    	srcfd = Open(filename, O_RDONLY, 0);    
    	srcp = Mmap(0, filesize, PROT_READ, MAP_PRIVATE, srcfd, 0);
   	Close(srcfd);                          
    	Rio_writen(fd, srcp, filesize);        
    	Munmap(srcp, filesize);                
}

/*
 * get_filetype - derive file type from file name
 */
void get_filetype(char *filename, char *filetype) 
{
    	if (strstr(filename, ".html"))
		strcpy(filetype, "text/html");
    	else if (strstr(filename, ".gif"))
		strcpy(filetype, "image/gif");
    	else if (strstr(filename, ".jpg"))
		strcpy(filetype, "image/jpeg");
    	else
		strcpy(filetype, "text/plain");
}  
/* $end serve_static */

/*
 * serve_dynamic - run a CGI program on behalf of the client
 */
/* $begin serve_dynamic */
void serve_dynamic(int fd, char *filename, char *cgiargs) 
{
    	char buf[MAXLINE], *emptylist[] = { NULL };

   	/* Return first part of HTTP response */
    	sprintf(buf, "HTTP/1.0 200 OK\r\n"); 
    	Rio_writen(fd, buf, strlen(buf));
    	sprintf(buf, "Server: Tiny Web Server\r\n");
    	Rio_writen(fd, buf, strlen(buf));
  
    	if (Fork() == 0) { /* child */ 
		/* Real server would set all CGI vars here */
		setenv("QUERY_STRING", cgiargs, 1); 
		Dup2(fd, STDOUT_FILENO);         /* Redirect stdout to client */
		Execve(filename, emptylist, environ); /* Run CGI program */
    	}
    	Wait(NULL); /* Parent waits for and reaps child */
}
/* $end serve_dynamic */

/*
 * clienterror - returns an error message to the client
 */
/* $begin clienterror */
void clienterror(int fd, char *cause, char *errnum, 
		 char *shortmsg, char *longmsg) 
{
    	char buf[MAXLINE], body[MAXBUF];

    	/* Build the HTTP response body */
    	sprintf(body, "<html><title>Tiny Error</title>");
    	sprintf(body, "%s<body bgcolor=""ffffff"">\r\n", body);
    	sprintf(body, "%s%s: %s\r\n", body, errnum, shortmsg);
    	sprintf(body, "%s<p>%s: %s\r\n", body, longmsg, cause);
    	sprintf(body, "%s<hr><em>The Tiny Web server</em>\r\n", body);

    	/* Print the HTTP response */
    	sprintf(buf, "HTTP/1.0 %s %s\r\n", errnum, shortmsg);
    	Rio_writen(fd, buf, strlen(buf));
    	sprintf(buf, "Content-type: text/html\r\n");
    	Rio_writen(fd, buf, strlen(buf));
    	sprintf(buf, "Content-length: %d\r\n\r\n", (int)strlen(body));
    	Rio_writen(fd, buf, strlen(buf));
    	Rio_writen(fd, body, strlen(body));
}
/* $end clienterror */

/* need to parse different things out of the uri
-
*/
void parseURI(char *uri, char *version){
	
}