/* (c) 2002-2004 by Marcin Wiacek and Michal Cihar */

#include "../../gsmstate.h"

#if defined(GSM_ENABLE_AT) || defined(GSM_ENABLE_BLUEAT) || defined(GSM_ENABLE_IRDAAT) || defined(GSM_ENABLE_DKU2AT)

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

#include "../../gsmcomon.h"
#include "at.h"

static GSM_Error AT_WriteMessage (GSM_StateMachine *s, unsigned const char *buffer,
				     int length, int type)
{
	int sent=0, write_data=0, i=0;

	GSM_DumpMessageText(s, buffer, length, type);
	GSM_DumpMessageBinary(s, buffer, length, type);

	if (s->Protocol.Data.AT.FastWrite) {
		while (sent != length) {
			write_data = s->Device.Functions->WriteDevice(s,buffer + sent, length - sent);

			if (write_data == 0 || write_data < 0) {
				return ERR_DEVICEWRITEERROR;
			}
			sent += write_data;
		}
	} else {
		for (i = 0; i < length; i++) {
			/* For some phones like Siemens M20 we need to wait a little
			 * after writing each char. Possible reason: these phones
			 * can't receive so fast chars or there is bug here in Gammu */
			write_data = s->Device.Functions->WriteDevice(s, buffer + i, 1);

			if (write_data != 1) {
				return ERR_DEVICEWRITEERROR;
			}
			usleep(1000);
		}
		usleep(400000);
	}
	return ERR_NONE;
}

typedef struct {
	const char	*text;
	int	lines;
	GSM_Phone_RequestID requestid;
} SpecialAnswersStruct;

GSM_Error AT_StateMachine(GSM_StateMachine *s, unsigned char rx_char)
{
	GSM_Protocol_Message 	Msg2;
	GSM_Protocol_ATData 	*d = &s->Protocol.Data.AT;
	size_t			i;

	/* These are lines with end of "normal" answers */
	static const char 		*StatusStrings[] = {
		/* Standard AT */
		"OK\r",
		"ERROR\r",

		/* AT with bad end of lines */
		"OK\n",
		"ERROR\n",

		/* Standard GSM */
		"+CME ERROR:",
		"+CMS ERROR:",

		/* Motorola A1200 */
		"MODEM ERROR:",

		/* Huawei */
		"COMMAND NOT SUPPORT",

		NULL};

	/* Some info from phone can be inside "normal" answers
	 * It starts with strings written here
	 */
	static const SpecialAnswersStruct SpecialAnswers[] = {
		/* Standard GSM */
		{"+CGREG:"	,1, ID_GetNetworkInfo},
		{"+CBM:"	,1, ID_All},
		{"+CMT:"	,2, ID_All},
		{"+CMTI:"	,1, ID_All},
		{"+CDS:"	,2, ID_All},
		{"+CDSI:"	,1, ID_All},
		{"+CREG:"	,1, ID_GetNetworkInfo},
		{"+CUSD"	,1, ID_All},
		{"+COLP"	,1, ID_All},
		{"+CLIP"	,1, ID_All},
		{"+CRING"	,1, ID_All},
		{"+CCWA"	,1, ID_All},
		{"+CLCC"	,1, ID_All},

		/* Standard AT */
		{"RING"		,1, ID_All},
		{"NO CARRIER"	,1, ID_All},
		{"NO ANSWER"	,1, ID_All},

		/* GlobeTrotter */
		{"_OSIGQ:"	,1, ID_All},
		{"_OBS:"	,1, ID_All},

		{"^SCN:"	,1, ID_All},

		/* Sony-Ericsson */
		{"*EBCA"	,1, ID_All},

		/* Samsung binary transfer end */
		{"SDNDCRC ="	,1, ID_All},
		/* Samsung reply to SSHT in some cases */
		{"SAMSUNG PTS DG Test", 1, ID_All},

		/* Cross PD1101wi reply to almost anything */
		{"NOT FOND ^,NOT CUSTOM AT", 1, ID_All},

		/* Motorola banner */
		{"+MBAN:"	,1, ID_All},

		/* HSPA CORPORATION */
		{"+ZEND"	,1, ID_All},

		/* Huawei */
		{"^RSSI:"	,1, ID_All}, /* ^RSSI:18 */
		{"^HCSQ:"	,1, ID_All}, /* ^HCSQ:"WCDMA",39,29,45 */
		{"^DSFLOWRPT:"	,1, ID_All}, /* ^DSFLOWRPT:00000124,00000082,00000EA6,0000000000012325,000000000022771D,0000BB80,0001F400 */
		{"^BOOT:"	,1, ID_All}, /* ^BOOT:27710117,0,0,0,75 */
		{"^MODE:"	,1, ID_All}, /* ^MODE:3,3 */
		{"^CSNR:"	,1, ID_All}, /* ^CSNR:-93,-23 */
		{"^HCSQ:"	,1, ID_All}, /* ^HCSQ:"LTE",59,50,161,24 */
		{"^SRVST:"	,1, ID_All}, /* ^SRVST:0 */
		{"^SIMST:"	,1, ID_All}, /* ^SIMST:1 */
		{"^STIN:"	,1, ID_All}, /* ^STIN: 7, 0, 0 */

		/* ONDA */
		{"+ZUSIMR:"	,1, ID_All}, /* +ZUSIMR:2 */

		{NULL		,1, ID_All}};

	/* We're starting new message */
	if (d->Msg.Length == 0) {
		/* Ignore leading CR, LF and ESC */
		if (rx_char == 10 || rx_char == 13 || rx_char == 27) {
			return ERR_NONE;
		}
		d->LineStart = 0;
	}

	/* Allocate more memory if needed */
	if (d->Msg.BufferUsed < d->Msg.Length + 2) {
		d->Msg.BufferUsed	= d->Msg.Length + 200;
		d->Msg.Buffer 		= (unsigned char *)realloc(d->Msg.Buffer,d->Msg.BufferUsed);
		if (d->Msg.Buffer == NULL) {
			return ERR_MOREMEMORY;
		}
	}

	/* Store current char in the buffer */
	d->Msg.Buffer[d->Msg.Length++] = rx_char;
	d->Msg.Buffer[d->Msg.Length  ] = 0;

	/* Parse char */
	switch (rx_char) {
	case 0:
		break;
	case 10:
	case 13:
		/* Store line end (if we did not do it in last char */
		if (! d->wascrlf) {
			d->LineEnd = d->Msg.Length - 1;
		}
		d->wascrlf = TRUE;

		/* Process line after \r\n */
		if (d->Msg.Length > 0 && rx_char == 10 && d->Msg.Buffer[d->Msg.Length - 2] == 13) {
			/* Process standard responses */
			for (i = 0; StatusStrings[i] != NULL; i++) {
				if (strncmp(StatusStrings[i],
							d->Msg.Buffer + d->LineStart,
							strlen(StatusStrings[i])) == 0) {
					s->Phone.Data.RequestMsg	= &d->Msg;
					s->Phone.Data.DispatchError	= s->Phone.Functions->DispatchMessage(s);
					d->Msg.Length			= 0;
					break;
				}
			}
			/* Generally hack for A2D */
			if (d->CPINNoOK) {
				if (strncmp("+CPIN: ",
						d->Msg.Buffer + d->LineStart,
						7) == 0) {
					s->Phone.Data.RequestMsg	= &d->Msg;
					s->Phone.Data.DispatchError	= s->Phone.Functions->DispatchMessage(s);
					d->Msg.Length			= 0;
					break;
				}
			}

			/* Check for incoming frames */
			for (i = 0; SpecialAnswers[i].text != NULL; i++) {
				if (strncmp(SpecialAnswers[i].text,
							d->Msg.Buffer + d->LineStart,
							strlen(SpecialAnswers[i].text)) == 0) {
					/* We need something better here */
					if (s->Phone.Data.RequestID == SpecialAnswers[i].requestid) {
						i++;
						continue;
					}
					if ((s->Phone.Data.RequestID == ID_SetOBEX || s->Phone.Data.RequestID == ID_DialVoice)&&
							strcmp(SpecialAnswers[i].text, "NO CARRIER") == 0) {
						i++;
						continue;
					}
					d->SpecialAnswerStart 	= d->LineStart;
					d->SpecialAnswerLines	= SpecialAnswers[i].lines;
				}
			}

			/* Last line of incoming frame */
			if (d->SpecialAnswerLines == 1) {
				/* This is end of special answer. We copy it and send to phone module */
				Msg2.Buffer = (unsigned char *)malloc(d->LineEnd - d->SpecialAnswerStart + 3);
				memcpy(Msg2. Buffer, d->Msg.Buffer + d->SpecialAnswerStart, d->LineEnd - d->SpecialAnswerStart + 2);
				Msg2.Length = d->LineEnd - d->SpecialAnswerStart + 2;
				Msg2.Buffer[Msg2.Length] = '\0';
				Msg2.Type = 0;

				s->Phone.Data.RequestMsg	= &Msg2;
				s->Phone.Data.DispatchError	= s->Phone.Functions->DispatchMessage(s);
				free(Msg2.Buffer);
				Msg2.Buffer = NULL;

				/* We cut special answer from main buffer */
				d->Msg.Length			= d->SpecialAnswerStart;
				if (d->Msg.Length != 0) {
					d->Msg.Length = d->Msg.Length - 2;
				}

				/* We need to find earlier values of all variables */
				d->wascrlf 			= FALSE;
				d->LineStart			= 0;
				for (i = 0;i < d->Msg.Length; i++) {
					switch (d->Msg.Buffer[i]) {
					case 0:
						break;
					case 10:
					case 13:
						if (!d->wascrlf) {
							d->LineEnd = d->Msg.Length - 1;
						}
						d->wascrlf = TRUE;
						break;
					default:
						if (d->wascrlf) {
							d->LineStart	= d->Msg.Length - 1;
							d->wascrlf 	= FALSE;
						}
					}
				}
				d->Msg.Buffer[d->Msg.Length] = 0;
			}
			if (d->SpecialAnswerLines > 0) {
				d->SpecialAnswerLines--;
			}
		}
		break;
	case 'T':
		/* When CONNECT string received, we know there will not follow
		 * anything AT related, after CONNECT can follow ppp data, alcabus
		 * data and also other things.
		 */
		if (strncmp(d->Msg.Buffer + d->LineStart, "CONNECT", 7) == 0) {
			s->Phone.Data.RequestMsg   	= &d->Msg;
			s->Phone.Data.DispatchError	= s->Phone.Functions->DispatchMessage(s);
			d->LineStart              	= -1;
			d->Msg.Length			= 0;
			break;
		}
	default:
		if (d->wascrlf) {
			d->LineStart	= d->Msg.Length - 1;
			d->wascrlf 	= FALSE;
		}
		if (d->EditMode) {
			if (strlen(d->Msg.Buffer+d->LineStart) == 2 &&
					strncmp(d->Msg. Buffer + d->LineStart, "> ", 2) == 0) {
				s->Phone.Data.RequestMsg	= &d->Msg;
				s->Phone.Data.DispatchError	= s->Phone.Functions->DispatchMessage(s);
			}
		}
	}
	return ERR_NONE;
}

GSM_Error AT_Initialise(GSM_StateMachine *s)
{
	GSM_Protocol_ATData *d = &s->Protocol.Data.AT;
	GSM_Error		error;

	d->Msg.Buffer 		= NULL;
	d->Msg.BufferUsed	= 0;
	d->Msg.Length		= 0;
	d->Msg.Type		= 0;

	d->SpecialAnswerLines	= 0;
	d->LineStart		= -1;
	d->LineEnd		= -1;
	d->wascrlf 		= FALSE;
	d->EditMode		= FALSE;
	/* Slow write makes sense only on cable for some phones */
	d->FastWrite		= (s->ConnectionType != GCT_AT);
	d->CPINNoOK		= FALSE;

	error = s->Device.Functions->DeviceSetParity(s, FALSE);
	if (error != ERR_NONE) return error;

	error = s->Device.Functions->DeviceSetDtrRts(s, TRUE, TRUE);
	if (error != ERR_NONE) return error;

	return s->Device.Functions->DeviceSetSpeed(s, s->Speed);
}

static GSM_Error AT_Terminate(GSM_StateMachine *s)
{
	free(s->Protocol.Data.AT.Msg.Buffer);
	s->Protocol.Data.AT.Msg.Buffer = NULL;
	return ERR_NONE;
}

GSM_Protocol_Functions ATProtocol = {
	AT_WriteMessage,
	AT_StateMachine,
	AT_Initialise,
	AT_Terminate
};

#endif

/* How should editor hadle tabs in this file? Add editor commands here.
 * vim: noexpandtab sw=8 ts=8 sts=8:
 */