#include "net.hpp"
#include <sys/types.h>

Socket::Socket() {
	sock_server = socket(AF_INET, SOCK_DGRAM, 0);
	sock_unix = -1;
	if (sock_server < 0) {
		throw runtime_error("Failed to create socket");
	}
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
}

Socket::~Socket() {
	close(sock_server);
	close(sock_unix);
}

void Socket::connect_server(const char *ip, uint16_t port, uint16_t port_input) {
    this->server_port_input = port_input;
	server_addr.sin_port = htons(port);
	if (inet_pton(AF_INET, ip, &server_addr.sin_addr) <= 0) {
		throw runtime_error("Invalid IP address");
	}
}

// Connect to existing UNIX domain socket (e.g., /tmp/socket_path)
void Socket::connect_unix(const char *ip, uint16_t port) {
	sock_unix = socket(AF_UNIX, SOCK_STREAM, 0);
	if (sock_unix < 0) {
		throw std::runtime_error("Failed to create UNIX socket");
	}

	this->server_addr_unix.sun_family = AF_UNIX;
	strncpy(this->server_addr_unix.sun_path, ip, sizeof(this->server_addr_unix.sun_path) - 1);

	if (connect(sock_unix, (struct sockaddr *)&server_addr_unix, sizeof(server_addr_unix)) < 0) {
		throw std::runtime_error("Failed to connect to UNIX socket");
	}
}

void Socket::send_server() {
	ssize_t sent_bytes = sendto(sock_server, &packet_data, sizeof(packet_data), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (sent_bytes < 0) {
		throw runtime_error("Failed to send data");
	}
}

void Socket::receive_server() {
    ssize_t recv_bytes = recvfrom(sock_server, buffer, sizeof(buffer), 0, NULL, NULL);
    if (recv_bytes < 0) {
        throw runtime_error("Failed to receive data");
    }
}

void Socket::send_unix() {
	ssize_t sent_bytes = send(sock_unix, &packet_data, sizeof(packet_data), 0);
	if (sent_bytes < 0) {
		throw runtime_error("Failed to send data to UNIX socket");
	}
}

void Socket::send_server(const api_packet &data) {
	ssize_t sent_bytes = sendto(sock_server, &data, sizeof(data), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (sent_bytes < 0) {
		throw runtime_error("Failed to send data");
	}
}

void Socket::send_server(const void *data, size_t len) {
	ssize_t sent_bytes = sendto(sock_server, data, len, 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (sent_bytes < 0) {
		throw runtime_error("Failed to send data");
	}
}

void Socket::send_unix(const api_packet &data) {
	ssize_t sent_bytes = send(sock_unix, &data, sizeof(data), 0);
	if (sent_bytes < 0) {
		throw runtime_error("Failed to send data to UNIX socket");
	}
}

void Socket::set_packet(const api_packet &data) {
	packet_data = data;
}

api_packet Socket::create_packet(uint8_t tracker_id) {
	api_packet pkt;
	memset(&pkt, 0, sizeof(pkt));

	pkt.message_type = 65; // Handshake message type
	pkt.tracker_id = tracker_id;
	return pkt;
}

api_packet Socket::get_packet() {
	return packet_data;
}