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

#include "buf.h"
#include "hex.h"
#include "packet.h"
#include "receive.h"
#include "uuid.h"

#include "airspy_adsb.h"

#define SEND_MHZ 20

struct __attribute__((packed)) airspy_adsb_common_overlay {
	uint8_t mlat_timestamp[8];
	char semicolon1;
	uint8_t mlat_precision[2];
	char semicolon2;
	uint8_t rssi[4];
	char semicolon3;
};

struct __attribute__((packed)) airspy_adsb_mode_s_short_overlay {
	char asterisk;
	uint8_t payload[14];
	char semicolon;
	struct airspy_adsb_common_overlay common;
	char cr_lf;
	char lf;
};

struct __attribute__((packed)) airspy_adsb_mode_s_long_overlay {
	char asterisk;
	uint8_t payload[28];
	char semicolon;
	struct airspy_adsb_common_overlay common;
	char cr_lf;
	char lf;
};

struct airspy_adsb_parser_state {
	struct packet_mlat_state mlat_state;
};

static bool airspy_adsb_parse_common(const struct airspy_adsb_common_overlay *overlay, struct packet *packet, struct airspy_adsb_parser_state *state) {
	if (overlay->semicolon1 != ';' ||
	    overlay->semicolon2 != ';' ||
			overlay->semicolon3 != ';') {
		return false;
	}
	uint16_t mlat_mhz = 2 * (uint16_t) hex_to_int(overlay->mlat_precision, sizeof(overlay->mlat_precision) / 2);
	if (!mlat_mhz) {
		return false;
	}
	int64_t mlat_timestamp_in = hex_to_int(overlay->mlat_timestamp, sizeof(overlay->mlat_timestamp) / 2);
	if (mlat_timestamp_in < 0) {
		return false;
	}
	packet->mlat_timestamp = packet_mlat_timestamp_scale_in((uint64_t) mlat_timestamp_in, UINT32_MAX, mlat_mhz, &state->mlat_state);
	packet->rssi = packet_rssi_scale_in((uint32_t) hex_to_int(overlay->rssi, sizeof(overlay->rssi) / 2), UINT16_MAX);
	return true;
}

static bool airspy_adsb_parse_mode_s_short(struct buf *buf, struct packet *packet, struct airspy_adsb_parser_state *state) {
	struct airspy_adsb_mode_s_short_overlay *overlay = (struct airspy_adsb_mode_s_short_overlay *) buf_at(buf, 0);
	if (((buf->length < sizeof(*overlay) - 1 || overlay->cr_lf != '\n') &&
			 (buf->length < sizeof(*overlay) || overlay->cr_lf != '\r' || overlay->lf != '\n')) ||
			overlay->asterisk != '*' ||
			overlay->semicolon != ';') {
		return false;
	}
	if (!airspy_adsb_parse_common(&overlay->common, packet, state)) {
		return false;
	}
	packet->type = PACKET_TYPE_MODE_S_SHORT;
	if (!hex_to_bin(packet->payload, overlay->payload, sizeof(overlay->payload) / 2)) {
		return false;
	}
	buf_consume(buf, overlay->cr_lf == '\r' ? sizeof(*overlay) : sizeof(*overlay) - 1);
	return true;
}

static bool airspy_adsb_parse_mode_s_long(struct buf *buf, struct packet *packet, struct airspy_adsb_parser_state *state) {
	struct airspy_adsb_mode_s_long_overlay *overlay = (struct airspy_adsb_mode_s_long_overlay *) buf_at(buf, 0);
	if (((buf->length < sizeof(*overlay) - 1 || overlay->cr_lf != '\n') &&
			 (buf->length < sizeof(*overlay) || overlay->cr_lf != '\r' || overlay->lf != '\n')) ||
			overlay->asterisk != '*' ||
			overlay->semicolon != ';') {
		return false;
	}
	if (!airspy_adsb_parse_common(&overlay->common, packet, state)) {
		return false;
	}
	packet->type = PACKET_TYPE_MODE_S_LONG;
	if (!hex_to_bin(packet->payload, overlay->payload, sizeof(overlay->payload) / 2)) {
		return false;
	}
	buf_consume(buf, overlay->cr_lf == '\r' ? sizeof(*overlay) : sizeof(*overlay) - 1);
	return true;
}

static void airspy_adsb_fill_common(struct packet *packet, struct airspy_adsb_common_overlay *overlay) {
	overlay->semicolon1 = overlay->semicolon2 = overlay->semicolon3 = ';';
	hex_from_int_upper(
			overlay->mlat_timestamp,
			packet_mlat_timestamp_scale_out(packet->mlat_timestamp, UINT32_MAX, SEND_MHZ),
			sizeof(overlay->mlat_timestamp) / 2);
	hex_from_int_upper(overlay->mlat_precision, SEND_MHZ / 2, sizeof(overlay->mlat_precision) / 2);
	hex_from_int_upper(overlay->rssi, packet_rssi_scale_out(packet->rssi, UINT16_MAX), sizeof(overlay->rssi) / 2);
}

static void airspy_adsb_serialize_mode_s_short(struct packet *packet, struct buf *buf) {
	struct airspy_adsb_mode_s_short_overlay *overlay = (struct airspy_adsb_mode_s_short_overlay *) buf_at(buf, 0);
	overlay->asterisk = '*';
	overlay->semicolon = ';';
	overlay->cr_lf = '\r';
	overlay->lf = '\n';
	hex_from_bin_upper(overlay->payload, packet->payload, sizeof(overlay->payload) / 2);

	airspy_adsb_fill_common(packet, &overlay->common);

	buf->length = sizeof(*overlay);
}

static void airspy_adsb_serialize_mode_s_long(struct packet *packet, struct buf *buf) {
	struct airspy_adsb_mode_s_long_overlay *overlay = (struct airspy_adsb_mode_s_long_overlay *) buf_at(buf, 0);
	overlay->asterisk = '*';
	overlay->semicolon = ';';
	overlay->cr_lf = '\r';
	overlay->lf = '\n';
	hex_from_bin_upper(overlay->payload, packet->payload, sizeof(overlay->payload) / 2);

	airspy_adsb_fill_common(packet, &overlay->common);

	buf->length = sizeof(*overlay);
}

void airspy_adsb_init() {
	assert(sizeof(struct airspy_adsb_parser_state) <= PARSER_STATE_LEN);
	assert(sizeof(struct airspy_adsb_mode_s_short_overlay) < BUF_LEN_MAX);
	assert(sizeof(struct airspy_adsb_mode_s_long_overlay) < BUF_LEN_MAX);
}

bool airspy_adsb_parse(struct buf *buf, struct packet *packet, void *state_in) {
	struct airspy_adsb_parser_state *state = (struct airspy_adsb_parser_state *) state_in;

	return (
			airspy_adsb_parse_mode_s_short(buf, packet, state) ||
			airspy_adsb_parse_mode_s_long(buf, packet, state));
}

void airspy_adsb_serialize(struct packet *packet, struct buf *buf) {
	switch (packet->type) {
		case PACKET_TYPE_NONE:
			break;

		case PACKET_TYPE_MODE_S_SHORT:
			airspy_adsb_serialize_mode_s_short(packet, buf);
			break;

		case PACKET_TYPE_MODE_S_LONG:
			airspy_adsb_serialize_mode_s_long(packet, buf);
			break;
	}
}