/* 
 * Copyright (c) 2023 Craig Peacock.
 * 
 * API Information:
 * https://docs.zephyrproject.org/3.2.0/connectivity/networking/api/http.html
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <stdio.h>
#include <stdlib.h>
#include <zephyr/net/socket.h>
#include <zephyr/kernel.h>
#include <zephyr/net/http/client.h>

void nslookup(const char * hostname, struct zsock_addrinfo **results)
{
	int err;
	
	struct zsock_addrinfo hints = {
		//.ai_family = AF_INET,     // Allow IPv4 Address
		.ai_family = AF_UNSPEC,		// Allow IPv4 or IPv6	
		.ai_socktype = SOCK_STREAM,
	};

	err = zsock_getaddrinfo(hostname, NULL, &hints, (struct zsock_addrinfo **) results);
	if (err) {
		printf("getaddrinfo() failed, err %d\n", errno);
		return;
	}
}

void print_addrinfo_results(struct zsock_addrinfo **results)
{
	char ipv4[INET_ADDRSTRLEN];
	char ipv6[INET6_ADDRSTRLEN];
	struct sockaddr_in *sa;
	struct sockaddr_in6 *sa6;
	struct zsock_addrinfo *rp;
	
	for (rp = *results; rp != NULL; rp = rp->ai_next) {
		if (rp->ai_addr->sa_family == AF_INET) {
			// IPv4 Address
			sa = (struct sockaddr_in *) rp->ai_addr;
			zsock_inet_ntop(AF_INET, &sa->sin_addr, ipv4, INET_ADDRSTRLEN);
			printf("IPv4: %s\n", ipv4);
		}
		if (rp->ai_addr->sa_family == AF_INET6) {
			// IPv6 Address
			sa6 = (struct sockaddr_in6 *) rp->ai_addr;
			zsock_inet_ntop(AF_INET6, &sa6->sin6_addr, ipv6, INET6_ADDRSTRLEN);
			printf("IPv6: %s\n", ipv6);
		}
	}
}

int connect_socket(struct zsock_addrinfo **results, uint16_t port)
{
	int sock;
	int ret;
	struct zsock_addrinfo *rp;
	struct sockaddr_in6 *sa6;

	// Create IPv6 Socket
	sock = zsock_socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
	if (sock < 0) {
		printk("Error creating IPv6 socket\n");
		return(-1);
	}

	// Iterate through IPv6 addresses until we get a successful connection
	for (rp = *results; rp != NULL; rp = rp->ai_next) {
		if (rp->ai_addr->sa_family == AF_INET6) {
			// IPv6 Address
			sa6 = (struct sockaddr_in6 *) rp->ai_addr;
			sa6->sin6_port = htons(port);
			
			char ipv6[INET6_ADDRSTRLEN];
			zsock_inet_ntop(AF_INET6, &sa6->sin6_addr, ipv6, INET6_ADDRSTRLEN);
			printk("Connecting to %s:%d ", ipv6, port);

			ret = zsock_connect(sock, (struct sockaddr *) sa6, sizeof(struct sockaddr_in));
			if (ret == 0) {
				printk("Success\r\n");
				return(sock);
			} else {
				printk("Failure (%d)\r\n", ret);
			}
		}
	}
	// Close IPv6 Socket
	zsock_close(sock);

	// Now try IPv4 Addresses
	struct sockaddr_in *sa;

	// Create IPv4 Socket
	sock = zsock_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (sock < 0) {
		printk("Error creating IPv4 socket\n");
		return(-1);
	}
	
	// Iterate through IPv4 addresses until we get a successful connection
	for (rp = *results; rp != NULL; rp = rp->ai_next) {
		if (rp->ai_addr->sa_family == AF_INET) {
			// IPv4 Address
			sa = (struct sockaddr_in *) rp->ai_addr;
			sa->sin_port = htons(port);

			char ipv4[INET_ADDRSTRLEN];
			zsock_inet_ntop(AF_INET, &sa->sin_addr, ipv4, INET_ADDRSTRLEN);
			printk("Connecting to %s:%d ", ipv4, port);

			ret = zsock_connect(sock, (struct sockaddr *) sa, sizeof(struct sockaddr_in));
			if (ret == 0) {
				printk("Success\r\n");
				return(sock);
			} else {
				printk("Failure (%d)\r\n", ret);
			}
		}
	}
	
	return(0);
}

static void http_response_cb(struct http_response *rsp,
			enum http_final_call final_data,
			void *user_data)
{
	if (final_data == HTTP_DATA_MORE) {
		//printk("Partial data received (%zd bytes)\n", rsp->data_len);
	} else if (final_data == HTTP_DATA_FINAL) {
		//printk("All the data received (%zd bytes)\n", rsp->data_len);
	}

	//printk("Bytes Recv %zd\n", rsp->data_len);
	//printk("Response status %s\n", rsp->http_status);
	//printk("Recv Buffer Length %zd\n", rsp->recv_buf_len);
	printk("%.*s", rsp->data_len, rsp->recv_buf);
}

void http_get(int sock, char * hostname, char * url)
{
	struct http_request req = { 0 };
	static uint8_t recv_buf[512];
	int ret;

	req.method = HTTP_GET;
	req.url = url;
	req.host = hostname;
	req.protocol = "HTTP/1.1";
	req.response = (void *)http_response_cb;
	req.recv_buf = recv_buf;
	req.recv_buf_len = sizeof(recv_buf);

	ret = http_client_req(sock, &req, 5000, NULL);
}

#ifndef HTTP_CLIENT_H_
#define HTTP_CLIENT_H_

#include <zephyr/net/socket.h>

/* 
 * Giải thích chi tiết từng dòng:
 * #ifndef HTTP_CLIENT_H_ và #define HTTP_CLIENT_H_: Đây được gọi là "Include Guard".
 * Nó ngăn chặn việc file header này bị include nhiều lần trong một file .c, 
 * một lỗi có thể gây ra việc định nghĩa lại các kiểu dữ liệu và báo lỗi biên dịch.
 * Quy ước đặt tên thường là <TÊN_FILE>_H_.
 */

/* 
 * Enum định nghĩa các trạng thái (states) của HTTP client.
 * Đây là trái tim của State Machine. Mỗi hằng số đại diện cho một bước
 * trong quy trình làm việc của client.
 */
enum http_client_state {
    HTTP_CLIENT_STATE_IDLE,          // Trạng thái nghỉ, chưa làm gì.
    HTTP_CLIENT_STATE_DNS_START,     // Bắt đầu quá trình phân giải DNS.
    HTTP_CLIENT_STATE_DNS_PENDING,   // Đang chờ kết quả DNS từ callback.
    HTTP_CLIENT_STATE_CONNECT_START, // Bắt đầu quá trình kết nối socket.
    HTTP_CLIENT_STATE_CONNECTING,    // Đang chờ kết nối socket thành công (dùng poll).
    HTTP_CLIENT_STATE_REQUEST_SEND,  // Gửi gói tin HTTP request.
    HTTP_CLIENT_STATE_RESPONSE_RECV, // Đang trong quá trình nhận response.
    HTTP_CLIENT_STATE_DONE,          // Hoàn thành, thành công.
    HTTP_CLIENT_STATE_ERROR,         // Trạng thái lỗi, dừng hoạt động.
};

/* 
 * Struct chứa toàn bộ "bộ não" và tài nguyên của một HTTP client instance.
 * Nó gói gọn tất cả dữ liệu cần thiết để duy trì trạng thái qua các lần
 * gọi hàm `http_client_run()` và trong các hàm callback.
 */
struct http_client_context {
    // Trạng thái hiện tại của state machine.
    enum http_client_state state;

    // File descriptor cho socket. -1 nghĩa là chưa được tạo.
    int sock;

    // Con trỏ tới danh sách kết quả địa chỉ IP từ DNS.
    // Chúng ta sẽ sớm thấy việc dùng con trỏ ở đây có rủi ro.
    struct zsock_addrinfo *addr_res;

    // Con trỏ tới địa chỉ IP hiện tại đang được thử kết nối.
    struct zsock_addrinfo *current_addr;

    // Các thông tin do người dùng cung cấp.
    char *hostname;
    char *url;
    uint16_t port;
};

/*
 * Khai báo các hàm công khai (public functions) mà các file .c khác
 * (như main.c) có thể gọi.
 */

/**
 * @brief Khởi tạo context cho HTTP client.
 */
void http_client_init(struct http_client_context *ctx, char *hostname, char *url, uint16_t port);

/**
 * @brief "Nhịp tim" của HTTP client, phải được gọi liên tục.
 */
int http_client_run(struct http_client_context *ctx);


#endif /* HTTP_CLIENT_H_ */

#include "http_client.h"
#include <zephyr/logging/log.h>

// Đăng ký một module log riêng cho file này, giúp việc debug dễ dàng hơn.
// Chúng ta có thể bật/tắt log của riêng module này trong prj.conf.
LOG_MODULE_REGISTER(http_client, LOG_LEVEL_INF);

void http_client_init(struct http_client_context *ctx, char *hostname, char *url, uint16_t port)
{
    // TODO: Sẽ được hiện thực ở bước sau.
}

int http_client_run(struct http_client_context *ctx)
{
    // TODO: Sẽ được hiện thực ở bước sau.
    return 0;
}

#include "http_client.h"
#include <zephyr/logging/log.h>
#include <string.h> // Thêm thư viện này để dùng hàm memset

LOG_MODULE_REGISTER(http_client, LOG_LEVEL_INF);

void http_client_init(struct http_client_context *ctx, char *hostname, char *url, uint16_t port)
{
    // Dùng memset để ghi toàn bộ byte trong struct ctx về 0.
    // Đây là cách nhanh và an toàn để reset một struct.
    memset(ctx, 0, sizeof(struct http_client_context));

    // Thiết lập các giá trị ban đầu cho phiên làm việc.
    ctx->state = HTTP_CLIENT_STATE_IDLE;
    ctx->hostname = hostname;
    ctx->url = url;
    ctx->port = port;
    ctx->sock = -1; // -1 là một giá trị quy ước cho "socket không hợp lệ".
}

// Hàm helper để đổi state, giúp debug dễ hơn
static void set_state(struct http_client_context *ctx, enum http_client_state new_state)
{
    // In ra sự thay đổi trạng thái giúp chúng ta biết chính xác chương trình đang làm gì.
    LOG_INF("State transition: %d -> %d", ctx->state, new_state);
    ctx->state = new_state;
}

int http_client_run(struct http_client_context *ctx)
{
    // Cấu trúc switch-case, trái tim của state machine.
    switch (ctx->state) {
    case HTTP_CLIENT_STATE_IDLE:
        // Khi ở IDLE, chúng ta tự động bắt đầu quá trình.
        LOG_INF("Client is IDLE, starting process.");
        set_state(ctx, HTTP_CLIENT_STATE_DNS_START);
        break;

    case HTTP_CLIENT_STATE_DNS_START:
        LOG_INF("Handling state: DNS_START");
        // TODO: Gọi hàm DNS lookup bất đồng bộ ở đây
        break;

    case HTTP_CLIENT_STATE_DNS_PENDING:
        LOG_INF("Handling state: DNS_PENDING - Doing nothing, waiting for callback.");
        // State này không làm gì trong hàm run(), nó chỉ chờ đợi một sự kiện từ bên ngoài (callback).
        break;

    case HTTP_CLIENT_STATE_CONNECT_START:
        LOG_INF("Handling state: CONNECT_START");
        // TODO: Bắt đầu quá trình kết nối non-blocking
        break;

    case HTTP_CLIENT_STATE_CONNECTING:
        LOG_INF("Handling state: CONNECTING");
        // TODO: Dùng poll() để kiểm tra kết nối
        break;

    case HTTP_CLIENT_STATE_REQUEST_SEND:
        LOG_INF("Handling state: REQUEST_SEND");
        // TODO: Gửi HTTP request
        break;

    case HTTP_CLIENT_STATE_RESPONSE_RECV:
        LOG_INF("Handling state: RESPONSE_RECV");
        // TODO: Nhận và xử lý response
        break;

    case HTTP_CLIENT_STATE_DONE:
        LOG_INF("Process finished successfully.");
        return 1; // Trả về > 0 để báo hiệu cho nơi gọi (main) là đã xong.

    case HTTP_CLIENT_STATE_ERROR:
        LOG_ERR("Process stopped due to an error.");
        return -1; // Trả về < 0 để báo hiệu lỗi.
    
default:
        LOG_ERR("Unknown state: %d", ctx->state);
        set_state(ctx, HTTP_CLIENT_STATE_ERROR);
        break;
    }

    return 0; // Trả về 0 để báo hiệu "vẫn đang chạy, chưa xong".
}

#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include "wifi.h"
#include "http_client.h" // <-- Include file mới của chúng ta

LOG_MODULE_REGISTER(main_module, LOG_LEVEL_INF);

#define WIFI_STACK_SIZE 4096

void wifi_thread_entry(void *a, void *b, void *c) {
	LOG_INF("Wifi thread is created");
	// wifi_init() là một hàm blocking, nó sẽ chờ đến khi có IP.
	// Sau khi nó chạy xong, chúng ta mới có mạng để bắt đầu state machine.
	wifi_init();

	// --- LOGIC MỚI VỚI STATE MACHINE ---
	struct http_client_context client_ctx;
	
	// Khởi tạo client của chúng ta với các thông tin cần thiết.
	http_client_init(&client_ctx, "iot.beyondlogic.org", "/LoremIpsum.txt", 80);

	// Vòng lặp "nhịp tim".
	while (1) {
		// Gọi hàm run() để thực thi một bước của state machine.
		int ret = http_client_run(&client_ctx);
		if (ret < 0) {
			LOG_ERR("HTTP client run failed");
			break; // Thoát vòng lặp nếu có lỗi.
		} else if (ret > 0) {
			LOG_INF("HTTP client run finished");
			break; // Thoát vòng lặp nếu hoàn thành.
		}
		// Cho thread nghỉ 100ms. Con số này có thể điều chỉnh.
		// Nó cân bằng giữa độ phản hồi của client và việc tiết kiệm CPU.
		k_sleep(K_MSEC(100));
	}
}

K_THREAD_DEFINE(wifi_thread, 
		WIFI_STACK_SIZE,
		wifi_thread_entry,
		NULL, NULL, NULL,
		7,0,0
		);

int main(void) {
	LOG_INF("Main is created");
	return 0;
}

#include "http_client.h"
#include <zephyr/logging/log.h>
#include <string.h>
#include <zephyr/net/dns_resolve.h> // <-- Thêm thư viện DNS

LOG_MODULE_REGISTER(http_client, LOG_LEVEL_INF);

// Hàm http_client_init và set_state giữ nguyên như Bước 2

// === HÀM CALLBACK MỚI CHO DNS ===
/*
 * @brief Hàm callback được gọi bởi DNS resolver khi có kết quả.
 *
 * @param status Trạng thái của việc phân giải (thành công, lỗi, timeout...).
 * @param info Con trỏ tới struct chứa thông tin địa chỉ. NULL nếu lỗi.
 * @param user_data Con trỏ mà chúng ta đã truyền vào lúc gọi dns_get_addr_info.
 */
static void dns_resolve_cb(enum dns_resolve_status status,
                         struct dns_addrinfo *info,
                         void *user_data)
{
    // Ép kiểu user_data trở lại thành con trỏ tới context của chúng ta.
    struct http_client_context *ctx = user_data;

    if (status != DNS_E_SUCCESS) {
        LOG_ERR("DNS resolution failed with status: %d", status);
        set_state(ctx, HTTP_CLIENT_STATE_ERROR);
        return; // Dừng lại ngay lập tức.
    }

    if (info == NULL || info->ai_addrlen == 0) {
        LOG_ERR("DNS resolution returned no addresses");
        set_state(ctx, HTTP_CLIENT_STATE_ERROR);
        return;
    }
    
    // !!! CẢNH BÁO "CHEAT" !!!
    // Lưu con trỏ kết quả vào context.
    // Đây là một cách làm TẠM THỜI để đơn giản hóa.
    // Lý do nó nguy hiểm: `info` là con trỏ tới một vùng nhớ được cấp phát bởi
    // DNS resolver. Chúng ta không biết vòng đời của nó. Nó có thể bị giải phóng
    // bất cứ lúc nào sau khi callback này kết thúc.
    // Ở bước sau, chúng ta sẽ sửa lại bằng cách sao chép dữ liệu thay vì lưu con trỏ.
    ctx->addr_res = (struct zsock_addrinfo *)info;
    
    LOG_INF("DNS resolution successful.");
    // Quan trọng nhất: Chuyển state machine sang bước tiếp theo!
    set_state(ctx, HTTP_CLIENT_STATE_CONNECT_START);
}

int http_client_run(struct http_client_context *ctx)
{
    switch (ctx->state) {
    case HTTP_CLIENT_STATE_IDLE:
        LOG_INF("Client is IDLE, starting process.");
        set_state(ctx, HTTP_CLIENT_STATE_DNS_START);
        break;

    case HTTP_CLIENT_STATE_DNS_START:
        LOG_INF("Handling state: DNS_START - Beginning DNS resolution");
        
        int ret = dns_get_addr_info(ctx->hostname,
                                    DNS_QUERY_TYPE_A, // Chỉ tìm địa chỉ IPv4 cho đơn giản
                                    NULL,
                                    dns_resolve_cb, // Con trỏ tới hàm callback
                                    (void *)ctx,    // Truyền context của chúng ta làm user_data
                                    1000);          // Timeout 1 giây
        if (ret < 0) {
            LOG_ERR("Failed to start DNS resolution: %d", ret);
            set_state(ctx, HTTP_CLIENT_STATE_ERROR);
        } else {
            // Chuyển sang trạng thái chờ callback
            set_state(ctx, HTTP_CLIENT_STATE_DNS_PENDING);
        }
        break;

    case HTTP_CLIENT_STATE_DNS_PENDING:
        // Trong trạng thái này, chúng ta không làm gì cả, chỉ chờ.
        // Có thể thêm logic timeout ở đây nếu muốn.
        break;

    case HTTP_CLIENT_STATE_CONNECT_START:
        LOG_INF("Handling state: CONNECT_START");
        break;
        
    case HTTP_CLIENT_STATE_CONNECTING:
        LOG_INF("Handling state: CONNECTING");
        break;
        
    case HTTP_CLIENT_STATE_REQUEST_SEND:
        LOG_INF("Handling state: REQUEST_SEND");
        break;
        
    case HTTP_CLIENT_STATE_RESPONSE_RECV:
        LOG_INF("Handling state: RESPONSE_RECV");
        break;
        
    case HTTP_CLIENT_STATE_DONE:
        LOG_INF("Process finished successfully.");
        return 1;
        
    case HTTP_CLIENT_STATE_ERROR:
        LOG_ERR("Process stopped due to an error.");
        return -1;
        
default:
        LOG_ERR("Unknown state: %d", ctx->state);
        set_state(ctx, HTTP_CLIENT_STATE_ERROR);
        break;
    }

    return 0;
}

#ifndef HTTP_CLIENT_H_
#define HTTP_CLIENT_H_

#include <zephyr/net/socket.h>

// Các enum state giữ nguyên như Bước 1

struct http_client_context {
    enum http_client_state state;
    int sock;

    // Loại bỏ các con trỏ không an toàn
    // struct zsock_addrinfo *addr_res;
    // struct zsock_addrinfo *current_addr;

    // Thay thế bằng một vùng nhớ an toàn trong chính context.
    struct sockaddr_storage current_addr;
    socklen_t current_addr_len;

    char *hostname;
    char *url;
    uint16_t port;
};

// Các khai báo hàm init và run giữ nguyên

#endif /* HTTP_CLIENT_H_ */

#include "http_client.h"
#include <zephyr/logging/log.h>
#include <string.h>
#include <zephyr/net/dns_resolve.h>
#include <zephyr/fcntl.h> // <-- Thêm thư viện cho fcntl

LOG_MODULE_REGISTER(http_client, LOG_LEVEL_INF);

// Hàm http_client_init và set_state giữ nguyên như Bước 2

static void dns_resolve_cb(enum dns_resolve_status status,
                         struct dns_addrinfo *info,
                         void *user_data)
{
    struct http_client_context *ctx = user_data;
    
    if (status != DNS_E_SUCCESS || info == NULL) {
        LOG_ERR("DNS resolution failed with status: %d", status);
        set_state(ctx, HTTP_CLIENT_STATE_ERROR);
        // Nếu info không phải NULL, vẫn phải giải phóng nó.
        if (info) {
            dns_free_addrinfo(info);
        }
        return;
    }

    // SAO CHÉP địa chỉ một cách an toàn.
    ctx->current_addr_len = info->ai_addrlen;
    memcpy(&ctx->current_addr, info->ai_addr, info->ai_addrlen);

    // GIẢI PHÓNG bộ nhớ ngay sau khi sao chép.
    dns_free_addrinfo(info);
    
    LOG_INF("DNS resolution successful, address copied.");
    set_state(ctx, HTTP_CLIENT_STATE_CONNECT_START);
}

int http_client_run(struct http_client_context *ctx)
{
    int ret;

    switch (ctx->state) {
    
    // Các case IDLE, DNS_START, DNS_PENDING giữ nguyên như Bước 3

    case HTTP_CLIENT_STATE_CONNECT_START:
        LOG_INF("Handling state: CONNECT_START");

        // Set port cho địa chỉ đã lưu trong context
        if (ctx->current_addr.ss_family == AF_INET) {
            // Ép kiểu sockaddr_storage thành sockaddr_in để set port
            ((struct sockaddr_in *)&ctx->current_addr)->sin_port = htons(ctx->port);
        } else if (ctx->current_addr.ss_family == AF_INET6) {
            // Tương tự cho IPv6
            ((struct sockaddr_in6 *)&ctx->current_addr)->sin6_port = htons(ctx->port);
        } else {
            LOG_ERR("Unknown address family: %d", ctx->current_addr.ss_family);
            set_state(ctx, HTTP_CLIENT_STATE_ERROR);
            break;
        }

        // Tạo socket dựa trên họ địa chỉ đã nhận được từ DNS
        ctx->sock = zsock_socket(ctx->current_addr.ss_family, SOCK_STREAM, IPPROTO_TCP);
        if (ctx->sock < 0) {
            LOG_ERR("Failed to create socket: %d", errno);
            set_state(ctx, HTTP_CLIENT_STATE_ERROR);
            break;
        }

        // Đặt socket ở chế độ non-blocking
        zsock_fcntl(ctx->sock, F_SETFL, O_NONBLOCK);

        // Bắt đầu kết nối
        ret = zsock_connect(ctx->sock, (struct sockaddr *)&ctx->current_addr, ctx->current_addr_len);
        // Kiểm tra lỗi, nhưng bỏ qua lỗi EINPROGRESS
        if (ret < 0 && errno != EINPROGRESS) {
            LOG_ERR("connect() failed: %d", errno);
            set_state(ctx, HTTP_CLIENT_STATE_ERROR);
        } else {
            LOG_INF("Connection initiated...");
            set_state(ctx, HTTP_CLIENT_STATE_CONNECTING);
        }
        break;

    case HTTP_CLIENT_STATE_CONNECTING:
        {
            struct zsock_pollfd fds[1];
            fds[0].fd = ctx->sock;
            fds[0].events = ZSOCK_POLLOUT; // Chúng ta chỉ quan tâm đến sự kiện "có thể ghi"

            // Poll với timeout 10ms
            ret = zsock_poll(fds, 1, 10);

            if (ret < 0) {
                LOG_ERR("poll() failed: %d", errno);
                set_state(ctx, HTTP_CLIENT_STATE_ERROR);
                break;
            }

            if (ret > 0) {
                // Kiểm tra xem có đúng là sự kiện POLLOUT không
                if (fds[0].revents & ZSOCK_POLLOUT) {
                    LOG_INF("Connection successful!");
                    set_state(ctx, HTTP_CLIENT_STATE_REQUEST_SEND);
                }
            }
            // Nếu ret == 0 (timeout), không làm gì cả. Vòng lặp `http_client_run`
            // ở main sẽ gọi lại hàm này để poll tiếp.
        }
        break;
    
    // ... các case còn lại giữ nguyên
    default:
        break;
    }
    return 0;
}

#ifndef HTTP_CLIENT_H_
#define HTTP_CLIENT_H_

#include <zephyr/net/socket.h>
#include <zephyr/net/http/client.h> // <-- Thêm thư viện HTTP client

#define RECV_BUF_SIZE 2048

struct http_client_context {
    enum http_client_state state;
    int sock;
    struct sockaddr_storage current_addr;
    socklen_t current_addr_len;
    char *hostname;
    char *url;
    uint16_t port;

    // Struct để chuẩn bị request cho thư viện http-client
    struct http_request req;
    // Buffer để thư viện http-client lưu response body vào
    uint8_t recv_buf[RECV_BUF_SIZE];
};

// Khai báo hàm giữ nguyên

void http_client_init(struct http_client_context *ctx, char *hostname, char *url, uint16_t port);
int http_client_run(struct http_client_context *ctx);


#endif /* HTTP_CLIENT_H_ */

#include "http_client.h"
#include <zephyr/logging/log.h>
#include <string.h>
#include <zephyr/net/dns_resolve.h> 
#include <zephyr/fcntl.h> 
#include <zephyr/net/http/client.h> // <-- Thêm thư viện HTTP client

LOG_MODULE_REGISTER(http_client, LOG_LEVEL_INF);

// Hàm init, set_state giữ nguyên như Bước 2

// === HÀM CALLBACK MỚI CHO HTTP RESPONSE ===
static void http_response_cb(struct http_response *rsp,
                           enum http_final_call final_data,
                           void *user_data)
{
    struct http_client_context *ctx = user_data;

    // body_frag_start là con trỏ tới đầu của mảnh body vừa nhận được.
    // body_frag_len là độ dài của nó.
    // Chúng ta chỉ in ra nội dung body, bỏ qua header.
    if (rsp->body_frag_len > 0) {
        printk("%.*s", rsp->body_frag_len, rsp->body_frag_start);
    }
    
    // final_data cho biết đây có phải là lần gọi callback cuối cùng không.
    if (final_data == HTTP_DATA_FINAL) {
        printk("\n--- HTTP transfer complete ---");
        // Đóng socket sau khi xong việc để giải phóng tài nguyên.
        (void)zsock_close(ctx->sock);
        ctx->sock = -1;
        // Chuyển state machine sang trạng thái kết thúc.
        set_state(ctx, HTTP_CLIENT_STATE_DONE);
    }
}


// Hàm dns_resolve_cb giữ nguyên như Bước 4

static void dns_resolve_cb(enum dns_resolve_status status,
                         struct dns_addrinfo *info,
                         void *user_data)
{
    struct http_client_context *ctx = user_data;
    
    if (status != DNS_E_SUCCESS || info == NULL) {
        LOG_ERR("DNS resolution failed with status: %d", status);
        set_state(ctx, HTTP_CLIENT_STATE_ERROR);
        if (info) {
            dns_free_addrinfo(info);
        }
        return;
    }

    ctx->current_addr_len = info->ai_addrlen;
    memcpy(&ctx->current_addr, info->ai_addr, info->ai_addrlen);

    dns_free_addrinfo(info);
    
    LOG_INF("DNS resolution successful, address copied.");
    set_state(ctx, HTTP_CLIENT_STATE_CONNECT_START);
}


int http_client_run(struct http_client_context *ctx)
{
    int ret;

    switch (ctx->state) {
    
    // Các case đến CONNECTING giữ nguyên như Bước 4

    case HTTP_CLIENT_STATE_REQUEST_SEND:
        LOG_INF("Handling state: REQUEST_SEND");

        // Chuẩn bị struct request.
        memset(&ctx->req, 0, sizeof(ctx->req));
        ctx->req.method = HTTP_GET;
        ctx->req.url = ctx->url;
        ctx->req.host = ctx->hostname;
        ctx->req.protocol = "HTTP/1.1";
        ctx->req.response = http_response_cb; // Đăng ký callback xử lý response.
        ctx->req.recv_buf = ctx->recv_buf;     // Cung cấp buffer nhận.
        ctx->req.recv_buf_len = sizeof(ctx->recv_buf);
        ctx->req.user_data = ctx; // Truyền context vào callback.

        // Gọi http_client_req. Hàm này sẽ gửi request và nhận response.
        // Nó sẽ block cho đến khi hoàn thành hoặc timeout (5000ms).
        ret = http_client_req(ctx->sock, &ctx->req, 5000, ctx);
        if (ret < 0) {
            LOG_ERR("http_client_req failed: %d", ret);
            set_state(ctx, HTTP_CLIENT_STATE_ERROR);
        } else {
            // Nếu không lỗi, chúng ta chỉ cần chuyển sang state chờ, 
            // vì callback `http_response_cb` sẽ là người chuyển sang DONE.
            set_state(ctx, HTTP_CLIENT_STATE_RESPONSE_RECV);
        }
        break;

    case HTTP_CLIENT_STATE_RESPONSE_RECV:
        // Trong state này, chúng ta không làm gì cả.
        // Toàn bộ logic nhận và xử lý đã được `http_client_req` và callback của nó đảm nhiệm.
        // Chúng ta chỉ ở đây chờ cho đến khi callback chuyển state sang DONE hoặc ERROR.
        break;

    case HTTP_CLIENT_STATE_DONE:
        LOG_INF("Process finished successfully.");
        return 1; // Báo hiệu hoàn thành

    case HTTP_CLIENT_STATE_ERROR:
        LOG_ERR("Process stopped due to an error.");
        // Đảm bảo socket được đóng nếu có lỗi xảy ra.
        if (ctx->sock >= 0) {
            (void)zsock_close(ctx->sock);
            ctx->sock = -1;
        }
        return -1; // Báo hiệu lỗi
    
default:
        // Các case khác sẽ rơi vào đây.
        break;
    }

    return 0; // Báo hiệu vẫn đang chạy
}