#include "./include/server.h"
#include "./include/util_http.h"
#include "./include/cJSON.h"
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <fcntl.h>

/**
 * 创建一个server socket
 */
int server_start() {
 int sock_fd;
 struct sockaddr_in server_addr;
 int flags;

 server_addr.sin_family = AF_INET; // 协议族是IPV4协议
 server_addr.sin_port = htons(PORT); // 将主机的无符号短整形数转换成网络字节顺序
 server_addr.sin_addr.s_addr = inet_addr(HOST); // 用inet_addr函数将字符串host转为int型

 sock_fd = socket(AF_INET, SOCK_STREAM, 0);

 // 获取服务器socket的设置,并添加"不阻塞"选项
 flags = fcntl(sock_fd, F_GETFL, 0);
 fcntl(sock_fd, F_SETFL, flags | O_NONBLOCK);

 if (bind(sock_fd, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1) {
 perror("bind_error");
 exit(1);
 }

 if (listen(sock_fd, REQUEST_QUEUE_LENGTH) == -1) {
 perror("listen error");
 exit(1);
 }

 return (sock_fd);
}

/**
 * 处理请求参数
 *
 * @param request_content
 */
char *deal_request(char *request_content, int client_fd) {
 struct sockaddr_in client_addr;
 socklen_t len_client_addr = sizeof(client_addr);
 struct request cgi_request;

 parse_request(request_content, &cgi_request);
 cgi_request.SERVER_PORT = PORT;
 getpeername(client_fd, (struct sockaddr *) &client_addr, &len_client_addr);
 inet_ntop(AF_INET, &client_addr.sin_addr, cgi_request.REMOTE_ADDR, sizeof(cgi_request.REMOTE_ADDR));

 char *request_json = create_json(&cgi_request);
 char *response_json = exec_php(request_json);

 // todo parse json and build http_response
 return response_json;
}

char *create_json(struct request *cgi_request) {
 cJSON *root;
 root = cJSON_CreateObject();

 cJSON_AddStringToObject(root, "REQUEST_METHOD", cgi_request->REQUEST_METHOD);
 cJSON_AddStringToObject(root, "SCRIPT_NAME", cgi_request->SCRIPT_NAME);
 cJSON_AddStringToObject(root, "SERVER_PROTOCOL", cgi_request->SERVER_PROTOCOL);
 cJSON_AddStringToObject(root, "SERVER_NAME", cgi_request->SERVER_NAME);
 cJSON_AddStringToObject(root, "QUERY_STRING", cgi_request->QUERY_STRING);
 cJSON_AddStringToObject(root, "REMOTE_ADDR", cgi_request->REMOTE_ADDR);
 cJSON_AddStringToObject(root, "CONTENT_TYPE", cgi_request->CONTENT_TYPE);
 cJSON_AddStringToObject(root, "POST_DATA", cgi_request->POST_DATA);
 cJSON_AddNumberToObject(root, "SERVER_PORT", cgi_request->SERVER_PORT);
 cJSON_AddNumberToObject(root, "CONTENT_LENGTH", cgi_request->CONTENT_LENGTH);

 char *json = cJSON_PrintUnformatted(root);

 cJSON_Delete(root);

 return json;
}

/*
 * todo define response struct and build response header
 void parse_json(char *response_json, struct response *cgi_response) {
 cJSON *json = cJSON_Parse(response_json);

 cgi_response.CONTENT_TYPE = cJSON_GetObjectItem(cJSON, "CONTENT_TYPE");
 cgi_response.HTTP_CODE = cJSON_GetObjectItem(cJSON, "HTTP_CODE");
 cgi_response.RESPONSE_CONTENT = cJSON_GetObjectItem(cJSON, "RESPONSE_CONTENT");

 return;
}
*/

/**
 * 执行PHP脚本以返回执行结果
 *
 * @param args
 * @return
 */
char *exec_php(char *args) {
 // 这里不能用变长数组,需要给command留下足够长的空间,以存储args参数,不然拼接参数时会栈溢出
 char command[BUFF_SIZE] = "php /tmp/index.php ";
 FILE *fp;
 static char buff[BUFF_SIZE]; // 声明静态变量以返回变量指针地址
 char line[BUFF_SIZE];
 strcat(command, args);
 memset(buff, 0, BUFF_SIZE); // 静态变量会一直保留,这里初始化一下
 if ((fp = popen(command, "r")) == NULL) {
 strcpy(buff, "服务器内部错误");
 } else {
 // fgets会在获取到换行时停止,这里将每一行拼接起来
 while (fgets(line, BUFF_SIZE, fp) != NULL) {
 strcat(buff, line);
 };
 }

 return buff;
}

/**
 * 注册epoll事件
 *
 * @param epoll_fd epoll句柄
 * @param fd socket句柄
 * @param state 监听状态
 */
void epoll_register(int epoll_fd, int fd, int state) {
 struct epoll_event event;
 event.events = state;
 event.data.fd = fd;
 epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &event);
}

/**
 * 注销epoll事件
 *
 * @param epoll_fd epoll句柄
 * @param fd socket句柄
 * @param state 监听状态
 */
void epoll_cancel(int epoll_fd, int fd, int state) {
 struct epoll_event event;
 event.events = state;
 event.data.fd = fd;
 epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, &event);
}

/**
 * 受理客户端连接
 *
 * @param server_fd
 * @param epoll_fd
 */
void accept_client(int server_fd, int epoll_fd) {
 int client_fd;
 struct sockaddr_in client_addr;
 socklen_t len_client_addr = sizeof(client_addr);

 client_fd = accept(server_fd, (struct sockaddr *) &client_addr, &len_client_addr);
 epoll_register(epoll_fd, client_fd, EPOLLIN);
}

/**
 * 处理客户端的请求信息
 *
 * @param client_fd
 * @param epoll_fd
 */
void deal_client(int client_fd, int epoll_fd) {
 char *response_content;
 char http_request[BUFF_SIZE], response_header[BUFF_SIZE], http_response[BUFF_SIZE];
 memset(http_request, 0, BUFF_SIZE); // 清空缓冲区内容
 
 // fixme, 超过BUFF_SIZE的数据接收不到,使用while循环接收数据,直到返回EAGAIN ERROR
 recv(client_fd, http_request, BUFF_SIZE, 0);

 // 如果收到请求内容为空的,表示客户端正常断开的连接
 if (strlen(http_request) == 0) {
 epoll_cancel(epoll_fd, client_fd, EPOLLIN);
 return;
 }

 response_content = deal_request(http_request, client_fd);
 sprintf(response_header, header_tmpl, strlen(response_content));
 sprintf(http_response, "%s%s", response_header, response_content);
 send(client_fd, http_response, sizeof(http_response), 0);
}

int main() {
 int i;
 int event_num;
 int server_fd;
 int epoll_fd;
 int fd;
 struct epoll_event events[MAX_EVENTS];

 server_fd = server_start();
 epoll_fd = epoll_create(FD_SIZE);
 epoll_register(epoll_fd, server_fd, EPOLLIN | EPOLLET);// 这里注册socketEPOLL事件为ET模式

 while (1) {
 event_num = epoll_wait(epoll_fd, events, MAX_EVENTS, 0);
 for (i = 0; i < event_num; i++) {
 fd = events[i].data.fd;
 if ((fd == server_fd) && (events[i].events == EPOLLIN)) {
 accept_client(server_fd, epoll_fd);
 } else if (events[i].events == EPOLLIN) {
 deal_client(fd, epoll_fd);
 } else if (events[i].events == EPOLLOUT)
 // todo 数据过大,缓冲区不足的情况待处理
 continue;
 }
 usleep(EPOLL_WAIT_US);
 }
}