path: root/server/main.ha

use bufio;
use bytes;
use errors;
use fmt;
use fs;
use io;
use net::ip;
use net::tcp;
use net;
use os;
use strings;
use time::chrono;
use time::date;
use time;
use unix::poll;

use drawing;
use drawing::{pos};
use packet_reader;


def PORT: u16 = 41460;
def CHUNKSIZE = 512;

type server_state = struct {
	connections: []connection,
	pictures: []drawing::picture,
	listener: net::socket,
	running: bool
};

type connection = struct {
	pr: packet_reader::packet_reader,
	sock: net::socket,
	pos: pos,
	should_delete: bool,
};


export fn main() void = {
	// create 4 pictures. later we will have more pictures
	// but for now there are just 4, and they are at fixed positions
	const offs: [_]pos = [
		(0,0), (0,CHUNKSIZE), (CHUNKSIZE,0), (CHUNKSIZE,CHUNKSIZE),
	];

	let pictures: []drawing::picture = alloc([],len(offs));
	for (let i = 0z; i < len(offs); i +=1){
		append(pictures, match (load_picture_from_file(offs[i])) {
			case let pic: drawing::picture => yield pic;
			case let err: fs::error => fmt::fatal(fs::strerror(err));
			case bad_header => fmt::fatal("bad ppm header");
		});
	};

	const listener = match(tcp::listen(ip::ANY_V4, PORT, tcp::reuseaddr)) {
	case let err: net::error =>
		fmt::fatalf(net::strerror(err));
	case let sock: net::socket =>
		yield sock;
	};

	let state = server_state {
		connections = [],
		pictures = pictures,
		listener = listener,
		running = true,
	};

	let now = time::now(time::clock::MONOTONIC);
	let next = time::add(now, save_interval);
	
	for (state.running) {
		const timeout = time::diff(now, next);
		fmt::println("running loop, timeout {}",timeout)!;
		loop(&state, timeout);

		now = time::now(time::clock::MONOTONIC);
		if (time::compare(now, next) >= 0) {
			fmt::println("saving world!")!;
			match (save_world(&state)) {
			case let e: fs::error =>
				fmt::fatalf("couldn't save world: {}",fs::strerror(e));
			case void => yield;
			};
			next = time::add(now, save_interval);
		};
	};



};

def save_interval = 20 * time::SECOND;

// caller should free return value
fn filename_from_world_pos(pos: pos) str =
	fmt::asprintf("./c.{}.{}.ppm",pos.0,pos.1);

fn save_world(state: *server_state) (void | fs::error) = {
	fmt::printfln("saving world!")!;
	for (const pic &.. state.pictures) {
		const filename = filename_from_world_pos(pic.world_pos);
		fmt::printfln("\t-> {}",filename)!;
		defer free(filename);

		const mode = fs::mode::USER_RW | fs::mode::GROUP_RW;
		const file = os::create(filename, mode)?;
		defer io::close(file): void;

		fmt::fprintf(file, "P6\n{} {}\n{}\n", pic.w, pic.h, 255)?;

		let buf: []u8 = alloc([0...],3*pic.w*pic.h);
		defer free(buf);
		for (let i = 0z; i < pic.w * pic.h; i += 1) {
			const px = pic.d[i];
			buf[3*i  ] = ((px>>16)&0xff): u8;
			buf[3*i+1] = ((px>>8) &0xff): u8;
			buf[3*i+2] = ((px)    &0xff): u8;
		};
		io::writeall(file, buf)?;
	};
		
};

fn new_picture(world_pos: pos) drawing::picture = {
	let picture_buf: []u32 = alloc([0xffffff...], CHUNKSIZE*CHUNKSIZE);
	return drawing::picture {
		w = CHUNKSIZE,
		h = CHUNKSIZE,
		d = picture_buf: *[*]u32,
		world_pos = world_pos,
	};
};

type bad_header = !void;

// loads the chunk at the given position from the filesystem,
// or, if no file is found, creates a fresh new chunk
fn load_picture_from_file(world_pos: pos) (drawing::picture | fs::error | bad_header) = {
	const filename = filename_from_world_pos(world_pos);
	defer free(filename);
	const file = match (os::open(filename)) {
		case let f: io::file => yield f;
		case errors::noentry => return new_picture(world_pos);
		case let e: fs::error => return e;
	};
	fmt::printfln("reading from {}",filename)!;
	defer {
		fmt::printfln("closing {}",filename)!;
		match (io::close(file)) {
			case let err: io::error => fmt::println("error",io::strerror(err))!;
			case => yield;
		};
	};

	const header = fmt::asprintf("P6\n{} {}\n{}\n",CHUNKSIZE,CHUNKSIZE,255);
	defer free(header);
	const header_bytes = strings::toutf8(header);
	let header_buf: []u8 = alloc([0...],len(header_bytes));
	defer free(header_buf);
	io::readall(file, header_buf)?;
	if (!bytes::equal(header_buf, header_bytes)) return bad_header;

	let file_buf: []u8 = alloc([0...], 3*CHUNKSIZE*CHUNKSIZE);
	defer free(file_buf);
	io::readall(file, file_buf)?;
	let picture_buf: []u32 = alloc([0...], CHUNKSIZE*CHUNKSIZE);
	for (let i = 0z; i < len(picture_buf); i += 1) {
		picture_buf[i] = (file_buf[3*i]:u32<<16)
						|(file_buf[3*i+1]:u32<<8)
						|(file_buf[3*i+2]:u32);
	};
	return drawing::picture {
		w = CHUNKSIZE,
		h = CHUNKSIZE,
		d = picture_buf: *[*]u32,
		world_pos = world_pos,
	};
};

// fn old_loop(listener: net::socket, pictures: []drawing::picture) void = {
// 	// pollfds[0] is the listener
// 	// pollfds[n>0] corresponds to packet_readers[n-1]
// 	let pollfds: []poll::pollfd = alloc([ poll::pollfd {
// 		fd = listener, events = poll::event::POLLIN, revents = 0
// 	}]);
// 	let packet_readers: []packet_reader::packet_reader = [];


// 	let now = time::now(time::clock::MONOTONIC);
// 	let next = time::add(now, save_interval);
// 	save_world(pictures);

// 	for (true) {
// 		fmt::println("poll.")!;
// 		const timeout = time::diff(now, next);
// 		poll::poll(pollfds, timeout)!;

// 		now = time::now(time::clock::MONOTONIC);
// 		if (time::compare(now, next) >= 0) {
// 			save_world(pictures);
// 			next = time::add(now, save_interval);
// 		};

// 		if (0 != pollfds[0].revents & poll::event::POLLIN) {
// 			fmt::println("new conn")!;
// 			const new_conn = tcp::accept(pollfds[0].fd)!;
// 			fmt::println("a")!;
// 			append(pollfds, poll::pollfd {
// 				fd = new_conn,
// 				events = poll::event::POLLIN, revents = 0
// 			});
// 			append(packet_readers, packet_reader::new());
// 			fmt::printfln("there are now {},{} conns.",len(pollfds),len(packet_readers))!;
// 			send_world(new_conn, pictures)!;
// 		};
// 		for (let connidx = 1z; connidx < len(pollfds); connidx += 1) {
// 			if (0 != pollfds[connidx].revents & poll::event::POLLIN) {
// 				match (packet_reader::read(&packet_readers[connidx-1], pollfds[connidx].fd)) {
// 				case void =>
// 					for (const packet => packet_reader::next(&packet_readers[connidx-1])!) {
// 						handle_packet(pictures, pollfds, packet, connidx);
// 					};
// 				case let err: io::error =>
// 					fmt::printfln("#{} error: {}",connidx,io::strerror(err))!;
// 					delete(pollfds[connidx]);
// 					delete(packet_readers[connidx-1]);
// 					connidx -= 1;
// 				case io::EOF =>
// 					fmt::printfln("#{} disconnect",connidx)!;
// 					delete(pollfds[connidx]);
// 					delete(packet_readers[connidx-1]);
// 					connidx -= 1;
// 				};
// 			};
// 		};
// 	};
// };

fn loop(state: *server_state, timeout: time::duration) void = {
	// do poll.
	let pollfds: []poll::pollfd = [];
	append(pollfds, poll::pollfd {
		fd = state.listener,
		events = poll::event::POLLIN,
		...
	});
	for (const conn &.. state.connections) {
		append(pollfds, poll::pollfd {
			fd = conn.sock,
			events = poll::event::POLLIN,
			...
		});
	};

	poll::poll(pollfds, timeout)!;

	// if listener: add connection
	if (0 != pollfds[0].revents & poll::event::POLLIN) {
		const new_conn = tcp::accept(pollfds[0].fd)!;
		append(state.connections, connection {
			sock = new_conn,
			pr = packet_reader::new(),
			pos = (0,0),
			should_delete = false,
		});
		fmt::printfln("there are now {} connections",
			len(state.connections))!;
		greet_connection(state, len(state.connections));
	};

	// for each connection, handle packet(s)
	// loop thru pollfds not state.connections so we don't
	// try to look at the nonexistent pollfd for a connection we just accepted
	for (let pollfd_idx = 1z: size; pollfd_idx < len(pollfds); pollfd_idx += 1) {
		const conn_idx = pollfd_idx - 1;
		fmt::println("checking conn {} with pollfd {}",conn_idx, pollfd_idx)!;
		if (0 != pollfds[conn_idx+1].revents & poll::event::POLLIN) {
			read_from_connection(state, conn_idx);
		};
	};

	perform_deletions(state);

};

fn perform_deletions(state: *server_state) void = {
	for (let i1 = len(state.connections); i1 > 0; i1 -= 1) {
		const i = i1 - 1;
		const conn = state.connections[i];
		if (conn.should_delete) {
			fmt::printfln("deleting conn {}",i)!;
			delete(state.connections[i]);
		};
	};
};

fn greet_connection(state: *server_state, conn_idx: size) void = void;


fn read_from_connection(state: *server_state, conn_idx: size) void = {
	const conn = &state.connections[conn_idx];
	match (packet_reader::read(&conn.pr, conn.sock)) {
	case let err: io::error =>
		fmt::printfln("#{} error: {}", conn_idx, io::strerror(err))!;
		conn.should_delete = true;
	case io::EOF =>
		fmt::printfln("#{} disconnect", conn_idx)!;
		conn.should_delete = true;
	case void =>
		for (true) match (packet_reader::next(&conn.pr)) {
			// foreach loop seems to break match exhaustivity here
			case done => break;
			case let p: packet_reader::packet =>
				handle_packet(state, conn_idx, p);
			case let e: packet_reader::error =>
				fmt::printfln("packet error {}",e)!;
				conn.should_delete = true;
			case => fmt::printfln("eoeugh")!;
			};
	};
};



fn handle_packet(
	state: *server_state,
	conn_idx: size,
	packet: packet_reader::packet
) void = {
	match (packet) {
	case let op: packet_reader::packet_drawop =>
		const opc = op as drawing::op_circle;
		fmt::printfln("#{}: drawop  ({:+6},{:+6})",conn_idx,opc.0,opc.1)!;
		drawing::perform(state.pictures, opc);
		for (let other_idx = 0z;
				other_idx < len(state.connections);
				other_idx += 1)
		{
			if (other_idx == conn_idx) continue;
			const other_conn = &state.connections[other_idx];
			if (other_conn.should_delete) continue;
			fmt::printfln("\t -> #{}",other_idx)!;
			match (packet_reader::send(other_conn.sock, packet)) {
			case void => yield;
			case let e: io::error =>
				fmt::printfln("couldn't send to #{}: {}",
					other_idx, io::strerror(e))!;
				other_conn.should_delete = true;
			};
		};
	case =>
		fmt::printfln("shouldn't be getting other packets from #{}",conn_idx)!;
		state.connections[conn_idx].should_delete = true;
	};
};

fn send_world(conn: io::file, pictures: []drawing::picture) (void | io::error) = {
	for (const pic &.. pictures) {
		fmt::printfln("  sending {},{}",pic.world_pos.0, pic.world_pos.1)!;
		packet_reader::send(conn, packet_reader::packet_sendchunk {
			world_pos = pic.world_pos,
			chunk_data = pic.d[..pic.w*pic.h],
		})?;
	};

};