/*
 * prezzyipc.c
 * Copyright (c) 2024 Jeremy Baxter.
 */

#define _PREZZYIPC_C_

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

#include "prezzyipc.h"

void
dumpPacket(PrezzyIpcPacket p)
{
	fprintf(stderr,
			"[packet]\n"
			"property = %d\n"
			"type = %d\n"
			"payload = ",
			p.property, p.type);
	if (p.type == PLT_STRING)
		fprintf(stderr, "%s\n", p.pString);
	else
		fprintf(stderr, "%ld\n", p.pInteger);
}

char *
fromIpcPacket(PrezzyIpcPacket p)
{
	char *buffer;

	buffer = malloc(PREZZY_PACKET_MAX * sizeof(char));

	if (p.type == PLT_STRING) {
		snprintf(buffer, PREZZY_PACKET_MAX, "%c%s\n",
				 p.property, p.pString);
	} else {
		snprintf(buffer, PREZZY_PACKET_MAX, "%c%ld\n",
				 p.property, p.pInteger);
	}

	return buffer;
}

PrezzyIpcPacket *
makeIpcPacket(const char *buffer)
{
	PrezzyIpcPacket *m;
	int i;

	m = malloc(sizeof(PrezzyIpcPacket));

	/* extract property */
	m->property = buffer[0];
	if (m->property < 0 || m->property >= PREZZY_PROPERTY_MAX)
		return NULL;

	/* determine payload type */
	m->type = payloadTypeMapping[m->property];

	switch (m->type) {
	case PLT_STRING:
		m->pString = NULL;
		for (i = 1; buffer[i] != '\n' && buffer[i] != '\0'
					&& i < PREZZY_PACKET_MAX; i++) {
			m->pString = realloc(m->pString, (i + 1) * sizeof(char));
			m->pString[i - 1] = buffer[i];
			m->pString[i] = '\0';
		}
		break;
	case PLT_INT64:
		m->pInteger = strtol(buffer + 1, NULL, 10);
		break;
	case PLT_INT:
		m->pInteger = squashLong(strtol(buffer + 1, NULL, 10));
		break;
	default: break;
	}

	return m;
}

int
squashLong(long l)
{
	return (l >= INT_MIN && l <= INT_MAX) ? l : INT_MAX ;
}

/*
 * Copy string src to buffer dst of size dsize.  At most dsize-1
 * chars will be copied.  Always NUL terminates (unless dsize == 0).
 * Returns strlen(src); if retval >= dsize, truncation occurred.
 */
size_t
strbcpy(char *dst, const char *src, size_t dsize)
{
	const char *osrc = src;
	size_t nleft = dsize;

	/* Copy as many bytes as will fit. */
	if (nleft != 0) {
		while (--nleft != 0) {
			if ((*dst++ = *src++) == '\0')
				break;
		}
	}

	/* Not enough room in dst, add NUL and traverse rest of src. */
	if (nleft == 0) {
		if (dsize != 0)
			*dst = '\0'; /* NUL-terminate dst */
		while (*src++)
			;
	}

	return (src - osrc - 1); /* count does not include NUL */
}

char *
stringFrom(const char *reference)
{
	char *buffer;
	size_t len;

	len = strlen(reference) + 1;
	buffer = malloc(len * sizeof(char));
	strbcpy(buffer, reference, len);

	return buffer;
}