/**
 * @file simp_httpd_m.c
 * @author maxwell@void
 * @version 0.2
 * @date 2024-07-12
 *
 * @copyright Copyright (c) 2024
 * 功能：
 * 1. 实现一个简单的HTTP服务器，可以处理GET请求，并返回指定文件的内容。
 * 2. 支持命令行参数，可以指定端口号和目录。
 * 3. 支持线程池，可以处理多个客户端连接。
 * 4. 支持SIGPIPE信号，可以忽略客户端断开连接时产生的错误。
 * 5. 这个版本支持连接池和持久连接
 * 编译：gcc -o sim_httpd_m simp_httpd_m.c -lpthread
 * 程序的流程是：
 * 1. 解析命令行参数，获取端口号和目录；如果没有指定，则使用默认目录和端口号
 * 2. 改变当前工作目录，使得服务器可以读取指定目录下的文件
 * 3. 忽略 SIGPIPE 信号，忽略客户端断开连接时产生的错误。否则会导致程序崩溃
 * 4. 初始化线程池，创建线程，并设置互斥锁、条件变量、任务队列、任务数量、关闭标志
 * 5. 创建服务器套接字，绑定到指定端口，监听连接
 * 6. 接受并处理客户端连接，向线程池添加任务
 * 7. 关闭服务器套接字，关闭线程池
 * 8. 线程池中的线程会从任务队列中获取任务，并处理任务，并通知其他线程
 * 9. 线程池中的线程在shutdown标志为1时退出循环
 * 10. 线程池中的线程在接收到SIGINT、SIGTERM信号时，会关闭线程池，并等待其他线程退出
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <signal.h>
#include <fcntl.h>
#include <jansson.h>

#define BUFFER_SIZE 1024          // 缓冲区大小
#define THREAD_POOL_SIZE 10       // 线程池大小
#define CONFIG_FILE "config.json" // 配置文件名

// 定义处理客户端连接的函数
void handle_client(int client_socket);
// 定义向客户端发送文件内容的函数
void send_file(int client_socket, const char *filename);

// 定义线程池相关函数
void *thread_worker(void *arg);
int read_config(int *port, char **directory, char *config_file);
int create_default_config(char *config_file);
// 线程池结构
typedef struct
{
    pthread_t threads[THREAD_POOL_SIZE]; // 线程数组
    pthread_mutex_t lock;                // 互斥锁
    pthread_cond_t cond;                 // 条件变量
    int client_sockets[BUFFER_SIZE];     // 客户端套接字数组
    int head, tail;                      // 头尾指针
    int count;                           // 任务数量
    int shutdown;                        // 关闭标志
} thread_pool_t;

// 全局线程池变量
thread_pool_t pool;

/**
 * @brief
 * 初始化线程池
 * 初始化线程池，创建线程，并设置互斥锁、条件变量、任务队列、任务数量、关闭标志
 */
void init_thread_pool()
{
    pthread_mutex_init(&pool.lock, NULL);   // 初始化互斥锁
    pthread_cond_init(&pool.cond, NULL);    // 初始化条件变量
    pool.head = pool.tail = pool.count = 0; // 初始化头尾指针和任务数量
    pool.shutdown = 0;                      // 初始化关闭标志
    // 创建线程
    for (int i = 0; i < THREAD_POOL_SIZE; i++)
    {
        pthread_create(&pool.threads[i], NULL, thread_worker, NULL);
    }
}

/**
 * @brief
 * 向线程池添加任务
 * 向线程池中添加一个任务，任务是客户端套接字
 * 线程池中的线程会从任务队列中获取任务，并处理任务
 * @param client_socket
 * 客户端套接字
 * @return void
 */
void add_task(int client_socket)
{
    pthread_mutex_lock(&pool.lock);                 // 加锁
    pool.client_sockets[pool.tail] = client_socket; // 添加任务
    pool.tail = (pool.tail + 1) % BUFFER_SIZE;      // 更新尾指针
    pool.count++;                                   // 任务数量加1
    pthread_cond_signal(&pool.cond);                // 通知线程
    pthread_mutex_unlock(&pool.lock);               // 解锁
}

/**
 * @brief 线程工作函数
 * 线程工作函数, 循环处理任务
 * 线程池中的线程调用这个函数，等待任务，处理任务，并通知其他线程
 * 线程池中的线程在shutdown标志为1时退出循环
 * 线程池中的线程在接收到SIGINT、SIGTERM信号时，会关闭线程池，并等待其他线程退出
 * @param arg
 * @return void*
 */
void *thread_worker(void *arg)
{
    (void)arg; // 没有用到arg参数，但为了保持接口一致性，这里保留
    while (1)
    {
        pthread_mutex_lock(&pool.lock); // 加锁
        while (pool.count == 0 && !pool.shutdown)
        {                                              // 等待任务
            pthread_cond_wait(&pool.cond, &pool.lock); // 等待条件变量
        }
        // 关闭线程池
        if (pool.shutdown)
        {
            pthread_mutex_unlock(&pool.lock);
            break;
        }
        // 处理任务
        int client_socket = pool.client_sockets[pool.head]; // 获取任务
        pool.head = (pool.head + 1) % BUFFER_SIZE;          // 更新头指针
        pool.count--;                                       // 任务数量减1
        pthread_mutex_unlock(&pool.lock);                   //   解锁
        handle_client(client_socket);                       // 处理客户端连接
        close(client_socket);                               // 关闭客户端套接字
    }
    return NULL;
}

/**
 * @brief
 * 关闭线程池
 * 关闭线程池，设置关闭标志，通知所有线程，等待线程退出
 */
void shutdown_thread_pool()
{
    pthread_mutex_lock(&pool.lock);     // 加锁
    pool.shutdown = 1;                  // 设置关闭标志
    pthread_cond_broadcast(&pool.cond); // 通知所有线程
    pthread_mutex_unlock(&pool.lock);   // 解锁
    // 等待线程退出
    for (int i = 0; i < THREAD_POOL_SIZE; i++)
    {
        pthread_join(pool.threads[i], NULL);
    }
}

/**
 * @brief
 * 读取配置文件。
 * 读取默认配置文件时，如果不存在，则创建默认配置文件。
 * @param port
 * @param directory
 * @param config_file
 * @return int
 */
int read_config(int *port, char **directory, char *config_file)
{
    // 判断config_file是否为json格式
    if (strstr(config_file, ".json") == NULL)
    {
        fprintf(stderr, "Config file is not a json file\n");
        return -1;
    }
    // 读取配置文件
    json_error_t error;
    json_t *root = json_load_file(config_file, 0, &error);
    if (!root)
    {
        fprintf(stderr, "Config file  failed: %s\n", error.text);
        return -1;
    }
    json_t *port_json = json_object_get(root, "port");
    if (!json_is_integer(port_json))
    {
        fprintf(stderr, "port is not an integer\n");
        json_decref(root);
        return -1;
    }
    *port = json_integer_value(port_json);

    json_t *directory_json = json_object_get(root, "directory");
    if (!json_is_string(directory_json))
    {
        fprintf(stderr, "directory is not a string\n");
        json_decref(root);
        return -1;
    }
    *directory = strdup(json_string_value(directory_json));

    json_decref(root);
    return 0;
}

/**
 * @brief 
 * 
 */
int create_default_config(char *config_file)
{
    json_t *root = json_object();
    json_object_set_new(root, "port", json_integer(8080));
    json_object_set_new(root, "directory", json_string("."));

    // 写入配置文件
    if (json_dump_file(root, config_file, JSON_INDENT(4)) < 0)
    {
        perror(" Failed to creat json file. \n");
        json_decref(root);
        return -1;
    }; 
    json_decref(root); // 释放内存
    return 0;
}


/**
 * @brief
 * 主函数
 * 解析命令行参数，创建服务器套接字，绑定到指定端口，监听连接，接受并处理客户端连接
 * @param argc
 * 程序参数个数
 * @param argv
 * 程序参数数组
 * @return int
 * 返回值
 */

int main(int argc, char *argv[])
{
    int server_socket, client_socket;                // 服务器套接字、客户端套接字
    struct sockaddr_in server_addr, client_addr;     // 服务器地址、客户端地址
    socklen_t client_addr_len = sizeof(client_addr); // 客户端地址长度
    int port = 8080;                                    // 默认端口
    char *directory = ".";                          // 默认目录
    char *config_file = NULL;                        // 配置文件路径
    // 如果不存在config.json,则创建

    if (access(CONFIG_FILE, F_OK) == -1)
    {
        if (create_default_config(CONFIG_FILE) == -1)
        {
            perror("Create default config file failed. \n");
        }
        printf("Create a default config file. \n");
    }
    // 解析命令行参数
    // 如果有-c 参数，则忽略其他参数，读取配置文件
    // 如果没有-c 参数，则读取命令行参数
    // 如果没有命令行参数，则读取默认配置文件
    // 如果没有默认配置文件，则创建默认配置文件
    int opt;
    while ((opt = getopt(argc, argv, "p:d:c:")) != -1)
    {
        switch (opt)
        {
        case 'p':
            port = atoi(optarg);
            break;
        case 'd':
            directory = optarg;
            break;
        case 'c':
            config_file = optarg;
            break;
        default:
            fprintf(stderr, "Usage: %s [-p port] [-d directory]\n", argv[0]);
            exit(EXIT_FAILURE);
        }
    }
    // 如果指定了配置文件或什么参数都没有，则读取配置文件
    if (optind < argc || config_file != NULL)
    {
        if (read_config(&port, &directory, config_file) == -1){
            perror("Read config file failed");
            exit(EXIT_FAILURE);
        }
    }

    // 改变当前工作目录，目的在于使得服务器可以读取指定目录下的文件
    if (chdir(directory) != 0)
    {
        perror("chdir failed");
        exit(EXIT_FAILURE);
    }

    // 忽略 SIGPIPE 信号，目的在于忽略客户端断开连接时产生的错误
    signal(SIGPIPE, SIG_IGN);

    // 初始化线程池，目的在于处理多个客户端连接
    init_thread_pool();

    // 创建服务器套接字，目的在于监听客户端连接
    server_socket = socket(AF_INET, SOCK_STREAM, 0); // 创建套接字, TCP, IPv4, 0表示默认协议
    if (server_socket == -1)
    {
        perror("Socket creation failed");
        exit(EXIT_FAILURE);
    }
    // For MacOS only,判断系统是否为MacOS

#ifdef __APPLE__
    // 创建SO_REUSEADDR套接字选项，使得服务器可以重用端口号
    int optval = 1;
    if (setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0)
    {
        perror("setsockopt failed");
        exit(EXIT_FAILURE);
    }
#endif

    // 设置服务器地址
    server_addr.sin_family = AF_INET;         // IPv4
    server_addr.sin_addr.s_addr = INADDR_ANY; // 监听所有地址。如果监听本地地址，可以改为INADDR_LOOPBACK
    server_addr.sin_port = htons(port);       // 端口号

    // 绑定套接字到指定端口,目的在于监听客户端连接
    if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1)
    { // 绑定地址, 地址长度
        perror("Bind failed");
        close(server_socket);
        exit(EXIT_FAILURE);
    }

    // 监听连接,10表示最大连接数
    if (listen(server_socket, 10) == -1)
    {
        perror("Listen failed");
        close(server_socket);
        exit(EXIT_FAILURE);
    }

    printf("Server is listening on port %d, serving directory %s...\n", port, directory);

    // 接受并处理客户端连接
    while (1)
    {
        client_socket = accept(server_socket, (struct sockaddr *)&client_addr, &client_addr_len); // 接受连接, 地址, 地址长度
        if (client_socket == -1)
        {
            perror("Accept failed");
            continue;
        }
        printf("Client connected: %s\n", inet_ntoa(client_addr.sin_addr));
        add_task(client_socket); // 向线程池添加任务
    }

    // 关闭服务器套接字
    close(server_socket);

    // 关闭线程池
    shutdown_thread_pool();

    return 0;
}

/**
 * @brief
 * 处理客户端连接
 * 处理客户端连接，接收请求，解析请求，发送响应
 * @param client_socket
 * 客户端套接字
 */
void handle_client(int client_socket)
{
    char buffer[BUFFER_SIZE]; // 缓冲区
    int received;             // 接收到的字节数
    while ((received = recv(client_socket, buffer, BUFFER_SIZE - 1, 0)) > 0)
    {                            // 接收请求, 缓冲区, 缓冲区大小, 0表示不等待
        buffer[received] = '\0'; // 结尾加上'\0'
        printf("Request: %s\n", buffer);

        // 简单解析HTTP GET请求
        char method[16], path[256], protocol[16];           // 方法、路径、协议
        sscanf(buffer, "%s %s %s", method, path, protocol); // 解析请求
        // 判断是否为GET请求
        if (strcmp(method, "GET") == 0)
        {
            // 去掉路径中的'/'
            if (path[0] == '/')
            {
                memmove(path, path + 1, strlen(path));
            }
            send_file(client_socket, path); // 发送文件内容
        }
        else
        {
            const char *response = "HTTP/1.1 405 Method Not Allowed\r\n\r\n";
            send(client_socket, response, strlen(response), 0); // 发送响应
        }

        // 检查是否为持久连接, 如果是持久连接，则继续接收请求，否则断开连接
        if (strstr(buffer, "Connection: keep-alive") == NULL)
        {
            break; // 非持久连接，断开
        }
    }
}

/**
 * @brief
 * 向客户端发送文件内容
 * 向客户端发送文件内容，读取文件内容，并发送给客户端
 * 发送响应头，包括Content-Length，并发送响应内容
 * 关闭客户端套接字
 * @param client_socket
 * @param filename
 */
void send_file(int client_socket, const char *filename)
{
    // 判断filename的长度,如果大于256,则返回414 Request-URI Too Long
    if (strlen(filename) > 256)
    {
        const char *response = "HTTP/1.1 414 Request-URI Too Long\r\n\r\n";
        send(client_socket, response, strlen(response), 0);
        close(client_socket);
        return;
    }
    // 判断filename是否为空,如果为空,则返回index.html
    if (strlen(filename) == 0)
    {
        filename = "index.html";
    }
    // 判断filename是否合法,如果不合法,则返回403 Forbidden
    if (filename[0] == '.' || strstr(filename, "..") != NULL)
    {
        const char *response = "HTTP/1.1 403 Forbidden\r\n\r\n";
        send(client_socket, response, strlen(response), 0);
        close(client_socket);
        return;
    }
    // 打开文件,如果文件不存在,则返回404 Not Found
    FILE *file = fopen(filename, "rb");
    if (file == NULL)
    {
        const char *response = "HTTP/1.1 404 Not Found\r\n\r\n";
        send(client_socket, response, strlen(response), 0);
        close(client_socket);
        return;
    }
    // 发送响应头,包括Content-Length
    fseek(file, 0, SEEK_END);     //     定位到文件末尾
    long file_size = ftell(file); // 获取文件大小
    fseek(file, 0, SEEK_SET);     //     定位到文件开头

    char header[BUFFER_SIZE]; // 响应头
    snprintf(header, BUFFER_SIZE, "HTTP/1.1 200 OK\r\nContent-Length: %ld\r\n\r\n", file_size);
    send(client_socket, header, strlen(header), 0);

    // 发送响应内容
    char file_buffer[BUFFER_SIZE]; // 文件缓冲区
    size_t bytes_read;             // 读取字节数
    // 循环读取文件内容，并发送给客户端
    while ((bytes_read = fread(file_buffer, 1, BUFFER_SIZE, file)) > 0)
    { // 读取文件内容, 缓冲区, 缓冲区大小, 文件
        if (send(client_socket, file_buffer, bytes_read, 0) == -1)
        { // 发送响应内容, 字节数, 0表示不等待
            perror("Send failed");
            break;
        }
    }

    fclose(file);
}