implement Esd;

include "sys.m";
include "draw.m";
include "math.m";
include "arg.m";
include "esd.m";

sys		: Sys;
arg		: Arg;
math		: Math;
Connection	: import Sys;

Esd : module
{
	init : fn(nil : ref Draw->Context, nil : list of string);
};

SAME, DIFFERENT : con 1 << iota;
port		:= ESD_PORT;
debug		:= 1;
pgrp		: int;
client_endian	:= SAME;

init(nil : ref Draw->Context, args : list of string)
{
	sys = load Sys Sys->PATH;
	arg = load Arg Arg->PATH;
        math = load Math Math->PATH;
	if (arg == nil || math == nil)
	{
		sys->raise(sys->sprint("Could not load %s : %r", Arg->PATH+"and "+Math->PATH));
	}
	arg->init(args);


	pgrp = sys->pctl(sys->NEWPGRP, nil);

	while((c := arg->opt()) != 0)
	{
		case c
		{
			'p'	=> port = int arg->arg();
             		*	=>
				usage();
				exit;
		}
	}

	(n, conn) := sys->announce("tcp!*!"+string port);
	if (n < 0)
	{
		sys->print("Esd : announce failed : %r\n");
		exit;
	}

	while (1)
	{
		listen(conn);
	}
}

listen(conn : Connection)
{
	buf := array [sys->ATOMICIO] of byte;
	
	(ok, c) := sys->listen(conn);
	if (ok < 0)
	{
		error(sys->sprint("Listen failed : %r\n"));
	}

	rfd := sys->open(conn.dir + "/remote", Sys->OREAD);
	n := sys->read(rfd, buf, len buf);
	spawn hdlrthread(c);


	return;
}

hdlrthread(conn : Connection)
{
	buf := array [sys->ATOMICIO] of byte;

	#	The connections data file is not opened by default,
	#	must explicitly do so to accept the new connection
	rdfd := sys->open(conn.dir + "/data", Sys->OREAD);
	wdfd := sys->open(conn.dir + "/data", Sys->OWRITE);
	rfd := sys->open(conn.dir + "/remote", Sys->OREAD);

	#	The client IP is now available, once we have accepted connection.
	#	The following will print the actual client IP address:
	iplen := sys->read(rfd, buf, len buf);
	debugprint(sys->sprint("Got new connection from %s",
			string buf[:iplen]));

	#	Read Key. BUG: Currently ignore the key sent
	keylen := sys->read(rdfd, buf, ESD_KEY_LEN);
	if (keylen != ESD_KEY_LEN)
	{
		error(sys->sprint("Runt key from client, length %d",
			keylen));
	}
	debugprint("client sent key :"+string buf[:keylen]);

	#	Read Endianness.
	endianlen := sys->read(rdfd, buf, ESD_ENDIAN_LEN);
	if (endianlen != ESD_ENDIAN_LEN)
	{
		error(sys->sprint("Runt endianess from client, length %d",
			endianlen));
	}
	debugprint("client sent endian: "+string buf[:endianlen]);
	if (int buf[0] == 'N')
	{
		client_endian = DIFFERENT;
	}

	#	Send response
	debugprint("About to write response to client...");
	if (sys->write(wdfd, scrub(OPCODE_RESPONSE), ESD_OPCODE_LEN) !=
		ESD_OPCODE_LEN)
	{
		error(sys->sprint("Could not write response to client: %r"));
	}
	debugprint("Wrote response to client...");

	#	Currently only accept "stream" writes. Read the opcode type from client
	oplen := sys->read(rdfd, buf, ESD_OPCODE_LEN);
	if (oplen != ESD_OPCODE_LEN)
	{
		error(sys->sprint("Runt opcode from client, length %d",
			oplen));
	}
		
	scrub(buf[:ESD_OPCODE_LEN]);	
	if (buf[0] == OPCODE_STREAM[0] && buf[1] == OPCODE_STREAM[1] &&
		buf[2] == OPCODE_STREAM[2] && buf[3] == OPCODE_STREAM[3])
	{
		debugprint("got a stream opcode...");
		#	Read and configure format and rate
		if (sys->read(rdfd, buf, ESD_FMT_LEN+ESD_RATE_LEN) != ESD_FMT_LEN+ESD_RATE_LEN)
		{
			error("Runt read getting format and rate from client");
		}
		configure_audio(scrub(buf[:ESD_FMT_LEN]), scrub(buf[ESD_FMT_LEN:ESD_FMT_LEN+ESD_RATE_LEN]));

		#	Read and discard name. Don't support Esd sample playing etc.
		if (sys->read(rdfd, buf, ESD_NAME_LEN) != ESD_NAME_LEN)
		{
			error("Runt read getting stream name from client");
		}

		#afd := sys->open("/tmp/junk.data", Sys->OWRITE);
		afd := sys->open("/dev/audio", Sys->OWRITE);
		if (afd == nil)
		{
			error(sys->sprint(
				"Could not open /dev/audio for writing: %r"));
		}
	
		#
		#	Read actual sound data and write to audio device.
		#	Writes are done in units smaller than ATOMICIO due 
		#	to some strange things occuring on large writes.
		#	Not yet sure who's the culprit.
		#
		chunklen := sys->read(rdfd, buf, 1024);
		while(chunklen != 0)
		{
			if (sys->write(afd, buf[:chunklen], chunklen) != chunklen)
			{
				error(sys->sprint(
					"Could not write %d bytes to /dev/audio: %r",
					chunklen));
			}
			debugprint(sys->sprint("wrote %d bytes to /dev/audio", chunklen));
			chunklen = sys->read(rdfd, buf, 1024);
		}
	}
	else
	{
		sys->sprint("Unknown opcode from client, %d%d%d%d",
			int buf[0], int buf[1], int buf[2], int buf[3]);
	}


	return;
}

#	Scrub() rearranges the byte order. Scrub is used
#	both taking the return value, or knowing it acts
#	on array reference.
scrub(data : array of byte) : array of byte
{
	if (client_endian == SAME)
	{
		return data;
	}

	for (i := 0; i < len data/2; i++)
	{
		tmp1 := int data[i];
		tmp2 := int data[len data - i - 1];

sys->print("\n\n%d --> %d\n", tmp1, tmp2);

		data[i] = byte tmp2;
		data[len data - i - 1] = byte tmp1;
	}
	
	return data;
}

configure_audio(fmt : array of byte, rate: array of byte)
{
	debugprint("ignoring config info, hope you don't mind");
}

debugprint(s: string)
{
	if (debug)
	{
		sys->print("Esd::DEBUG %s\n", s);
	}

	return;
}

usage()
{
	sys->print("Usage:\nesd [-p port]\n\n");

	return;
}

error(s: string)
{
	sys->raise("fail: Esd:: "+s);

	exit;
}