#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#define _GNU_SOURCE
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#include <glib.h>

#include <ofono/log.h>
#include <ofono/modem.h>
#include <ofono/netreg.h>
#include <ofono/spn-table.h>

#include "common.h"
#include "gril.h"

#include "grilreply.h"
#include "grilrequest.h"
#include "grilunsol.h"
#include <ofono/netreg.h>
static void ril_network_state_change(struct ril_msg *message,
							gpointer user_data)
{
	struct ofono_netreg *netreg = user_data;
	struct netreg_data *nd = ofono_netreg_get_data(netreg);

	g_ril_print_unsol_no_args(nd->ril, message);

	ril_registration_status(netreg, NULL, NULL);
}

static void ril_strength_notify(struct ril_msg *message, gpointer user_data)
{
	struct ofono_netreg *netreg = user_data;
	struct netreg_data *nd = ofono_netreg_get_data(netreg);
	int strength = g_ril_unsol_parse_signal_strength(nd->ril, message,
								nd->tech);

	ofono_netreg_strength_notify(netreg, strength);
}

static void ril_nitz_notify(struct ril_msg *message, gpointer user_data)
{
	struct ofono_netreg *netreg = user_data;
	struct netreg_data *nd = ofono_netreg_get_data(netreg);
	int year, mon, mday, hour, min, sec, dst, tzi, n_match;
	char tzs, tz[4];
	gchar *nitz;

	nitz = g_ril_unsol_parse_nitz(nd->ril, message);
	if (nitz == NULL)
		goto error;

	n_match = sscanf(nitz, "%u/%u/%u,%u:%u:%u%c%u,%u", &year, &mon,
				&mday, &hour, &min, &sec, &tzs, &tzi, &dst);
	if (n_match != 9)
		goto error;

	sprintf(tz, "%c%d", tzs, tzi);

	nd->time.utcoff = atoi(tz) * 15 * 60;
	nd->time.dst = dst;
	nd->time.sec = sec;
	nd->time.min = min;
	nd->time.hour = hour;
	nd->time.mday = mday;
	nd->time.mon = mon;
	nd->time.year = 2000 + year;

	ofono_netreg_time_notify(netreg, &nd->time);

	g_free(nitz);

	return;

error:
	ofono_error("%s: unable to notify ofono about NITZ (%s)",
						__func__, nitz ? nitz : "null");
	g_free(nitz);
}

static gboolean ril_delayed_register(gpointer user_data)
{
	struct ofono_netreg *netreg = user_data;
	struct netreg_data *nd = ofono_netreg_get_data(netreg);
	ofono_netreg_register(netreg);

	/* Register for network state changes */
	g_ril_register(nd->ril, RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED,
			ril_network_state_change, netreg);

	/* Register for network time update reports */
	g_ril_register(nd->ril, RIL_UNSOL_NITZ_TIME_RECEIVED,
			ril_nitz_notify, netreg);

	/* Register for signal strength changes */
	g_ril_register(nd->ril, RIL_UNSOL_SIGNAL_STRENGTH,
			ril_strength_notify, netreg);

	g_ril_register(nd->ril, MTK2_RIL_UNSOL_RESPONSE_REGISTRATION_SUSPENDED,
			mtk2_reg_suspended, netreg);

	/* This makes the timeout a single-shot */
	return FALSE;
}


struct mtk2_ril_data {
	GRil *ril;
	enum ofono_ril_vendor vendor;
	int sim_status_retries;
	ofono_bool_t init_state;
	ofono_bool_t ofono_online;
	int radio_state;
	struct ofono_sim *sim;
	int rild_connect_retries;
	GRilMsgIdToStrFunc request_id_to_string;
	GRilMsgIdToStrFunc unsol_request_to_string;
	ril_get_driver_type_func get_driver_type;
	struct cb_data *set_online_cbd;
	int suspend_id;
}

static void mtk2_reg_suspended(struct ril_msg *message, gpointer user_data)
{
	struct ofono_modem *modem = user_data;
	struct mtk2_ril_data *md = ofono_modem_get_data(modem);
	struct parcel rilp;
	int session_id;

	session_id = g_mtk2_unsol_parse_registration_suspended(md->ril, message);
	if (session_id < 0) {
		ofono_error("%s: parse error", __func__);
		return;
	}

	g_mtk2_request_resume_registration(md->ril, session_id, &rilp);
}

void g_mtk2_request_resume_registration(GRil *gril, int session_id,
					struct parcel *rilp)
{
	parcel_init(rilp);
	parcel_w_int32(rilp, 1);
	parcel_w_int32(rilp, session_id);

	g_ril_append_print_buf(gril, "(%d)", session_id);
}

int g_mtk2_unsol_parse_registration_suspended(GRil *gril,
						const struct ril_msg *message)
{
	struct parcel rilp;
	int numint, session_id;

	g_ril_init_parcel(message, &rilp);

	numint = parcel_r_int32(&rilp);
	if (numint != 1) {
		ofono_error("%s Wrong format", __func__);
		goto error;
	}

	session_id = parcel_r_int32(&rilp);

	if (rilp.malformed) {
		ofono_error("%s: malformed parcel", __func__);
		goto error;
	}

	g_ril_append_print_buf(gril, "{%d}", session_id);
	g_ril_print_unsol(gril, message);

	return session_id;

error:
	return -1;

}