#include <stdlib.h>
#include <termio.h>
#include <termios.h>
#include <sys/fcntl.h>

typedef struct {
	int len;
	char* buf;
} packet_t;



short generate_checksum(char input);
void dump_packet (packet_t* p);
packet_t* build_packet(char* amessage,char slot);


int main (int argc, char** argv) 
{
	char* input;
	int i;
	packet_t* p;
	int fd;
    char slot;


    if (argc != 3)
       exit(1);
    slot = atoi(argv[1]);

	input = argv[2];

	printf("Checksumming: X%sX\n", input);
	p = build_packet(input,slot);
	dump_packet(p);

	printf("Sending out\n");

	fd = open_serial("/dev/sign");
	writen(fd,p->buf,p->len);
	printf("Sent out\n");

	printf("\n");	

}


short generate_checksum(char input)
{
	static short mask = 0;
	static short checksum = 0xa55a;
	static short sum = 0;

	short temp = 0;
	short rottemp = 0;
	int final = 0;

	printf(" I:%x ",input);


	/*temp = input & 0x00ff;*/
	temp = input;
	temp = temp ^ mask;

	sum += temp;

	printf(" Mask = %x ", mask);

	mask++;
	/*mask = mask & 0x000f;*/
	if(mask > 255) { mask = 0x0;}


	checksum += sum;

	
	rottemp = checksum & 1;
	rottemp = rottemp << 0x000f;

	checksum = checksum >> 1;
	checksum = checksum & 0x7fff;
	checksum = checksum | rottemp;

	final = checksum;

	printf ("Final: %x\n", final);
	return final;
}

packet_t* build_packet(char* amessage, char slot) 
{

	packet_t* return_packet;
	char* packet;

	int i;

	const char header0 = 0x00;
	const char header1 = 0xff;
	const char header2 = 0x35;
	const char header3 = 0x35;
	short l;
	short l1;
	short checksum1;
	const char header4 = 0x00;
	short l2;
	const short effect = 0x0017;
	const char header5 = 0x02;
	const char footer = 0x1f;
	short checksum2;
	packet_t p2;



	l = strlen(amessage);
	l1 = l;
	l2 = l;
	packet = malloc(l + 24);

	memcpy(&packet[0], &header0, 1);
	memcpy(&packet[1], &header0, 1);
	memcpy(&packet[2], &header0, 1);
	memcpy(&packet[3], &header0, 1);
	memcpy(&packet[4], &header0, 1);
	memcpy(&packet[5], &header0, 1);
	memcpy(&packet[6], &header0, 1);
	memcpy(&packet[7], &header1, 1);
	memcpy(&packet[8], &header2, 1);
	memcpy(&packet[9], &header3, 1);

	l1 += 0x000a;
	memcpy(&packet[10], (char *)&l1+1, 1);
	memcpy(&packet[11], &l1, 1);

	generate_checksum(0x35);
	generate_checksum(0x35);
	generate_checksum(l1 >> 8);
	checksum1 = generate_checksum( l1 & 0x0ff );

	memcpy(&packet[12], (char *)&checksum1 + 1, 1);
	memcpy(&packet[13], &checksum1, 1);

	memcpy(&packet[14], &slot, 1);
	memcpy(&packet[15], &header4, 1);
	generate_checksum(slot);
	generate_checksum(0x00);

	l2 += 0x0004;
	memcpy(&packet[16], (char *)&l2 + 1, 1);
	memcpy(&packet[17], &l2, 1);
	generate_checksum(l2 >> 8);
	generate_checksum(l2);

	memcpy(&packet[18], (char *)&effect + 1, 1);
	memcpy(&packet[19], &effect, 1);
	generate_checksum(effect >> 8);
	generate_checksum(effect);

	memcpy(&packet[20], &header5, 1);
	generate_checksum(header5);

	memcpy(&packet[21], amessage, strlen(amessage));
	memcpy(&packet[strlen(amessage)+21], &footer, 1);

	for (i = 0; i < strlen(amessage); i++) {
		checksum2 = generate_checksum(amessage[i]);
	}

	checksum2 = generate_checksum(footer);

	memcpy(&packet[strlen(amessage)+22], (char *)&checksum2 + 1, 1);
	memcpy(&packet[strlen(amessage)+23], &checksum2, 1);


	return_packet = malloc(sizeof(packet_t));
	return_packet->buf = packet;
	return_packet->len = strlen(amessage) + 24;

	return return_packet;

}


void dump_packet (packet_t* p) {
	int i;
	unsigned char c;

	printf("\n");
	for (i = 0; i < p->len; i++) {
		c = p->buf[i];
		printf("%x ",c);
	}
	printf("\n");

}

int open_serial(char* path) {

	int fd;

	struct termios T;

	fd = open(path, O_WRONLY);

	tcgetattr(fd, &T);

	T.c_cflag |= CS8;
	T.c_cflag &= ~(PARENB | CRTSCTS);

	tcsetattr(fd, TCSANOW, &T);

	cfsetispeed(&T, B2400);
	cfsetospeed(&T, B2400);


	return fd;

}


/*
 * Write "n" bytes to a descriptor.
 * Use in place of write() when fd is a stream socket.
 */

int writen(int fd, char *ptr, int nbytes)
{
	int	nleft, nwritten;

	nleft = nbytes;
	while (nleft > 0) {
		nwritten = write(fd, ptr, nleft);
		if (nwritten <= 0)
			return(nwritten);		/* error */

		nleft -= nwritten;
		ptr   += nwritten;
	}
	return(nbytes - nleft);
}