module SMPP_Emulation {

/* SMPP Emulation layer, sitting on top of SMPP_CodecPort.
 *
 * (C) 2018 by Harald Welte <laforge@gnumonks.org>
 * All rights reserved.
 *
 * Released under the terms of GNU General Public License, Version 2 or
 * (at your option) any later version.
 */


import from Osmocom_Types all;
import from General_Types all;
import from SMPP_Types all;
import from SMPP_Templates all;
import from SMPP_CodecPort all;
import from SMPP_CodecPort_CtrlFunct all;
import from IPL4asp_Types all;
import from IPL4asp_PortType all;
import from Socket_API_Definitions all;

/* general "base class" component definition, of which specific implementations
 * derive themselves by menas of the "extends" feature */
type component SMPP_ConnHdlr {
	/* port towards SPPP_Emulation_CT */
	port SMPP_Conn_PT SMPP;
	port SMPPEM_PROC_PT SMPP_PROC;
}


type component SMPP_Emulation_CT {
	/* down-facing port to SMPP Codec port */
	port SMPP_CODEC_PT SMPP_PORT;
	var IPL4asp_Types.ConnectionId g_smpp_conn_id := -1;

	var integer g_seq := 1;

	/* up-facing port to Clients */
	port SMPP_Conn_PT SMPP_CLIENT;
	port SMPPEM_PROC_PT SMPP_PROC;

	var TransactionData TransactionTable[32];
	var ExpectData ExpectTable[32];
}

type port SMPP_Conn_PT message {
	inout SMPP_PDU;
} with { extension "internal" };

type record TransactionData {
	uint32_t	tid optional,
	SMPP_ConnHdlr	vc_conn
}

type record ExpectData {
	SMPP_TON	dst_ton optional,
	SMPP_NPI	dst_npi optional,
	charstring	dst_addr,
	SMPP_ConnHdlr	vc_conn
}

private function f_trans_id_known(uint32_t tid)
runs on SMPP_Emulation_CT return boolean {
	for (var integer i := 0; i < sizeof(TransactionTable); i := i+1) {
		if (TransactionTable[i].tid == tid) {
			return true;
		}
	}
	return false;
}

private function f_comp_known(SMPP_ConnHdlr client)
runs on SMPP_Emulation_CT return boolean {
	for (var integer i := 0; i < sizeof(TransactionTable); i := i+1) {
		if (TransactionTable[i].vc_conn == client) {
			return true;
		}
	}
	return false;
}

private function f_comp_by_trans_id(uint32_t tid)
runs on SMPP_Emulation_CT return SMPP_ConnHdlr {
	for (var integer i := 0; i < sizeof(TransactionTable); i := i+1) {
		if (TransactionTable[i].tid == tid) {
			return TransactionTable[i].vc_conn;
		}
	}
	setverdict(fail, "No componten for SMPP TID ", tid);
	mtc.stop;
}


private function f_trans_table_init()
runs on SMPP_Emulation_CT {
	for (var integer i := 0; i < sizeof(TransactionTable); i := i+1) {
		TransactionTable[i].vc_conn := null;
		TransactionTable[i].tid := omit;
	}
}

private function f_trans_table_add(SMPP_ConnHdlr vc_conn, uint32_t trans_id)
runs on SMPP_Emulation_CT {
	for (var integer i := 0; i < sizeof(TransactionTable); i := i+1) {
		if (TransactionTable[i].vc_conn == null) {
			TransactionTable[i].vc_conn := vc_conn;
			TransactionTable[i].tid := trans_id;
			return;
		}
	}
	testcase.stop("SMPP Trans table full!");
}

private function f_trans_table_del(uint32_t trans_id)
runs on SMPP_Emulation_CT {
	for (var integer i := 0; i < sizeof(TransactionTable); i := i+1) {
		if (TransactionTable[i].tid == trans_id) {
			TransactionTable[i].vc_conn := null;
			TransactionTable[i].tid := omit;
			return;
		}
	}
	setverdict(fail, "SMPP Trans table attempt to delete non-existant ", trans_id);
	mtc.stop;
}



function f_connect(charstring remote_host, IPL4asp_Types.PortNumber remote_port,
		   charstring local_host, IPL4asp_Types.PortNumber local_port)
runs on SMPP_Emulation_CT {
	var IPL4asp_Types.Result res;
	res := SMPP_CodecPort_CtrlFunct.f_IPL4_connect(SMPP_PORT, remote_host, remote_port,
							local_host, local_port, 0, { tcp :={} });
	if (not ispresent(res.connId)) {
		setverdict(fail, "Could not connect to SMPP port, check your configuration");
		mtc.stop;
	}
	g_smpp_conn_id := res.connId;
}

/* Function to use to bind to a local port as IPA server, accepting remote clients */
function f_bind(charstring local_host, IPL4asp_Types.PortNumber local_port)
runs on SMPP_Emulation_CT {
	var IPL4asp_Types.Result res;
	res := SMPP_CodecPort_CtrlFunct.f_IPL4_listen(SMPP_PORT, local_host, local_port, { tcp:={} });
	g_smpp_conn_id := res.connId;
}


function main_server(EsmePars pars, charstring local_host, integer local_port)
runs on SMPP_Emulation_CT {
	f_bind(local_host, local_port);
	f_mainloop(pars);
}

function main_client(EsmePars pars, charstring remote_host, integer remote_port,
			charstring local_host, integer local_port)
runs on SMPP_Emulation_CT {
	f_connect(remote_host, remote_port, local_host, local_port);
	f_mainloop(pars);
}

type enumerated EsmeMode {
	MODE_TRANSMITTER,
	MODE_RECEIVER,
	MODE_TRANSCEIVER
}
type record EsmePars {
	EsmeMode	mode,
	SMPP_Bind	bind,
	boolean		esme_role
}

private function f_tx_smpp(template (value) SMPP_PDU pdu) runs on SMPP_Emulation_CT {
	pdu.header.seq_num := g_seq;
	SMPP_PORT.send(ts_SMPP_Send(g_smpp_conn_id, pdu));
	g_seq := g_seq+1;
}

private function f_rx_smpp(template SMPP_PDU pdu) runs on SMPP_Emulation_CT {
	timer T_wait := 3.0;
	T_wait.start;
	alt {
	[] SMPP_PORT.receive(tr_SMPP_Recv(g_smpp_conn_id, pdu)) { }
	[] T_wait.timeout {
		setverdict(fail, "Timeout waiting for ", pdu);
		mtc.stop;
		}
	}
}

/* default altstep which we use throughout */
private altstep as_smpp() runs on SMPP_Emulation_CT {
	var SMPP_ConnHdlr vc_conn;
	var SMPP_RecvFrom smpp_rf;
	/* Answer to ENQUIRE LINK */
	[] SMPP_PORT.receive(tr_SMPP_Recv(g_smpp_conn_id,
			     tr_SMPP(c_SMPP_command_id_enquire_link, ESME_ROK))) {
		f_tx_smpp(ts_SMPP_ENQ_LINK_resp);
		}
	[] SMPP_PORT.receive(tr_SMPP_Recv(g_smpp_conn_id,
			     tr_SMPP(c_SMPP_command_id_alert_notification, ESME_ROK))) -> value smpp_rf {
		/* TODO: dispatch to ConnHdlr based on some kind of expect mechanism? */
		vc_conn := f_exp_lookup(smpp_rf.msg.body.alert_notif.source_addr_ton,
					smpp_rf.msg.body.alert_notif.source_addr_npi,
					smpp_rf.msg.body.alert_notif.source_addr);
		SMPP_CLIENT.send(smpp_rf.msg) to vc_conn;
		}
	[] SMPP_PORT.receive {
		setverdict(fail, "Unexpected SMPP from peer");
		mtc.stop;
		}
}

function f_mainloop(EsmePars pars)
runs on SMPP_Emulation_CT {

	/* Set function for dissecting the binary stream into packets */
	var f_IPL4_getMsgLen vl_f := refers(f_IPL4_fixedMsgLen);
	/* Offset: 0, size of length: 4, delta: 0, multiplier: 1, big-endian */
	SMPP_CodecPort_CtrlFunct.f_IPL4_setGetMsgLen(SMPP_PORT, g_smpp_conn_id, vl_f, {0, 4, 0, 1, 0});

	f_trans_table_init();
	f_expect_table_init();

	/* activate default altstep */
	var default d := activate(as_smpp());

	if (pars.esme_role) {
		/* BIND to SMSC */
		select (pars.mode) {
		case (MODE_TRANSMITTER) {
			f_tx_smpp(ts_SMPP_BIND_TX(pars.bind));
			/* FIXME: do we have to check for SEQ? */
			f_rx_smpp(tr_SMPP(c_SMPP_command_id_bind_transmitter_resp, ESME_ROK, g_seq));
			}
		case (MODE_RECEIVER) {
			f_tx_smpp(ts_SMPP_BIND_RX(pars.bind));
			/* FIXME: do we have to check for SEQ? */
			f_rx_smpp(tr_SMPP(c_SMPP_command_id_bind_receiver_resp, ESME_ROK, g_seq));
			}
		case (MODE_TRANSCEIVER) {
			f_tx_smpp(ts_SMPP_BIND_TRX(pars.bind));
			/* FIXME: do we have to check for SEQ? */
			f_rx_smpp(tr_SMPP(c_SMPP_command_id_bind_transceiver_resp, ESME_ROK));
			}
		}
	} else {
		var SMPP_Bind_resp bresp := {
			system_id := pars.bind.system_id,
			opt_pars := {}
		}
		/* Expect bind from ESME */
		select (pars.mode) {
		case (MODE_TRANSMITTER) {
			f_rx_smpp(tr_SMPP_BIND_TX(pars.bind));
			/* FIXME: do we have to check for SEQ? */
			f_tx_smpp(ts_SMPP_BIND_TX_resp(ESME_ROK, bresp));
			}
		case (MODE_RECEIVER) {
			f_rx_smpp(tr_SMPP_BIND_RX(pars.bind));
			/* FIXME: do we have to check for SEQ? */
			f_tx_smpp(ts_SMPP_BIND_RX_resp(ESME_ROK, bresp));
			}
		case (MODE_TRANSCEIVER) {
			f_rx_smpp(tr_SMPP_BIND_TRX(pars.bind));
			/* FIXME: do we have to check for SEQ? */
			f_tx_smpp(ts_SMPP_BIND_TRX_resp(ESME_ROK, bresp));
			}
		}
	}

	while (true) {
		var SMPP_ConnHdlr vc_conn;
		var SMPP_RecvFrom smpp_rf;
		var SMPP_PDU smpp;
		var charstring dest_addr;
		alt {
		/* SMSC -> CLIENT: response, map by seq_nr */
		[pars.esme_role] SMPP_PORT.receive(tr_SMPP_Recv(g_smpp_conn_id,
							tr_SMPP_esme_resp)) -> value smpp_rf {
			var uint32_t trans_id := smpp_rf.msg.header.seq_num;
			if (f_trans_id_known(trans_id)) {
				vc_conn := f_comp_by_trans_id(trans_id);
				SMPP_CLIENT.send(smpp_rf.msg) to vc_conn;
				f_trans_table_del(trans_id);
			} else {
				log("Received SMPP response for unknown trans_id ", smpp_rf);
				/* FIXME */
			}
			}
		/* SMSC -> CLIENT: DELIVER-SM.req */
		[pars.esme_role] SMPP_PORT.receive(tr_SMPP_Recv(g_smpp_conn_id,
				tr_SMPP(c_SMPP_command_id_deliver_sm, ESME_ROK))) -> value smpp_rf {
			vc_conn := f_exp_lookup(smpp_rf.msg.body.deliver_sm.dest_addr_ton,
						smpp_rf.msg.body.deliver_sm.dest_addr_npi,
						smpp_rf.msg.body.deliver_sm.destination_addr);
			SMPP_CLIENT.send(smpp_rf.msg) to vc_conn;
			}

		/* record seq_nr for commands from CLIENT -> SMSC */
		[pars.esme_role] SMPP_CLIENT.receive(tr_SMPP_esme_req) -> value smpp sender vc_conn {
			/* register current seq_nr/trans_id */
			f_trans_table_add(vc_conn, g_seq);
			f_tx_smpp(smpp);
			}
		/* pass responses 1:1 through from CLIENT -> SMSC */
		[pars.esme_role] SMPP_CLIENT.receive(tr_SMPP_smsc_resp) -> value smpp sender vc_conn {
			SMPP_PORT.send(ts_SMPP_Send(g_smpp_conn_id, smpp));
			}

		[] SMPP_PROC.getcall(SMPPEM_register:{?,?}) -> param(dest_addr, vc_conn) {
			f_create_expect(dest_addr, vc_conn);
			SMPP_PROC.reply(SMPPEM_register:{dest_addr, vc_conn}) to vc_conn;
			}
		}
	}
}

/* Requests from ESME -> SMSC */
template OCT4 SMPP_esme_req := (
	c_SMPP_command_id_submit_sm,
	c_SMPP_command_id_replace_sm,
	c_SMPP_command_id_cancel_sm,
	c_SMPP_command_id_submit_multi
);
template SMPP_PDU tr_SMPP_esme_req := tr_SMPP(SMPP_esme_req, ?);

/* Responses from ESME -> SMSC */
template OCT4 SMPP_esme_resp := (
	c_SMPP_command_id_submit_sm_resp,
	c_SMPP_command_id_replace_sm_resp,
	c_SMPP_command_id_cancel_sm_resp,
	c_SMPP_command_id_submit_multi_resp
);
template SMPP_PDU tr_SMPP_esme_resp := tr_SMPP(SMPP_esme_resp, ?);

/* Requests from SMSC -> ESME */
template OCT4 SMPP_smsc_req := (
	c_SMPP_command_id_deliver_sm
);
template SMPP_PDU tr_SMPP_smsc_req := tr_SMPP(SMPP_smsc_req, ?);

/* Responses from SMSC -> ESME */
template OCT4 SMPP_smsc_resp := (
	c_SMPP_command_id_deliver_sm_resp
);
template SMPP_PDU tr_SMPP_smsc_resp := tr_SMPP(SMPP_smsc_resp, ?);



signature SMPPEM_register(charstring dst_addr, SMPP_ConnHdlr hdlr);

type port SMPPEM_PROC_PT procedure {
	inout SMPPEM_register;
} with { extension "internal" };

private function f_create_expect(charstring dest_number, SMPP_ConnHdlr hdlr)
runs on SMPP_Emulation_CT {
	for (var integer i := 0; i < sizeof(ExpectTable); i := i+1) {
		if (ExpectTable[i].vc_conn == null) {
			ExpectTable[i] := {
				dst_ton := omit,
				dst_npi := omit,
				dst_addr := dest_number,
				vc_conn := hdlr
			}
			return;
		}
	}
	testcase.stop("No space left in SmppExpectTable");
}

private function f_exp_lookup(SMPP_TON ton, SMPP_NPI npi, charstring dst)
runs on SMPP_Emulation_CT return SMPP_ConnHdlr {
	for (var integer i := 0; i < sizeof(ExpectTable); i := i+1) {
		if (ExpectTable[i].vc_conn != null and ExpectTable[i].dst_addr == dst) {
			if (ispresent(ExpectTable[i].dst_ton) and ExpectTable[i].dst_ton != ton) {
				continue;
			}
			if (ispresent(ExpectTable[i].dst_npi) and ExpectTable[i].dst_npi != npi) {
				continue;
			}
			return ExpectTable[i].vc_conn;
		}
	}
	return null;
}
private function f_expect_table_init()
runs on SMPP_Emulation_CT {
	for (var integer i := 0; i < sizeof(ExpectTable); i := i+1) {
		ExpectTable[i] := {
			dst_ton := omit,
			dst_npi := omit,
			dst_addr := "",
			vc_conn := null
		};
	}
}





/* client/conn_hdlr side function to use procedure port to create expect in emulation */
function f_create_smpp_expect(charstring dest_number) runs on SMPP_ConnHdlr {
	SMPP_PROC.call(SMPPEM_register:{dest_number, self}) {
		[] SMPP_PROC.getreply(SMPPEM_register:{?,?}) {};
	}
}


}