// Fidelix ToolsView.cpp : implementation of the CFidelixToolsView class
//

#include "stdafx.h"
#include "Fidelix Tools.h"
#include "Fidelix ToolsDoc.h"
#include "Fidelix ToolsView.h"
#include "serial.h"
#include "serialthread.h"
#include "TestingReport.h"
#include "ext_h.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CFidelixToolsView

IMPLEMENT_DYNCREATE(CFidelixToolsView, CFormView)

BEGIN_MESSAGE_MAP(CFidelixToolsView, CFormView)
	//{{AFX_MSG_MAP(CFidelixToolsView)
	ON_EN_CHANGE(IDC_COMMAND_EDIT, OnChangeCommandEdit)
	ON_COMMAND(ID_COM_OPEN, OnComOpen)
	ON_WM_TIMER()
	ON_COMMAND(ID_COM_CLOSE, OnComClose)
	ON_COMMAND(ID_TEST_BEGIN, OnTestBegin)
	ON_COMMAND(ID_TEST_STOP, OnTestStop)
	ON_COMMAND(ID_TEST_REPORT, OnTestReport)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CFormView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CFormView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CFormView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CFidelixToolsView construction/destruction

CFidelixToolsView::CFidelixToolsView()
	: CFormView(CFidelixToolsView::IDD)
{
	//{{AFX_DATA_INIT(CFidelixToolsView)
	//}}AFX_DATA_INIT
	// TODO: add construction code here
	m_test_flag		= FALSE;
	m_test_count	= 0;
	m_test_phase	= 0;

	RSSIstr = "";
}

CFidelixToolsView::~CFidelixToolsView()
{
}

void CFidelixToolsView::DoDataExchange(CDataExchange* pDX)
{
	CFormView::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CFidelixToolsView)
	DDX_Control(pDX, IDC_MESSAGE_EDIT, m_message);
	DDX_Control(pDX, IDC_COMMAND_EDIT, m_command);
	//}}AFX_DATA_MAP
}

BOOL CFidelixToolsView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CFormView::PreCreateWindow(cs);
}

void CFidelixToolsView::OnInitialUpdate()
{


	CFormView::OnInitialUpdate();
	GetParentFrame()->RecalcLayout();
	ResizeParentToFit();

}

/////////////////////////////////////////////////////////////////////////////
// CFidelixToolsView printing

BOOL CFidelixToolsView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CFidelixToolsView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CFidelixToolsView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

void CFidelixToolsView::OnPrint(CDC* pDC, CPrintInfo* /*pInfo*/)
{
	// TODO: add customized printing code here
}

/////////////////////////////////////////////////////////////////////////////
// CFidelixToolsView diagnostics

#ifdef _DEBUG
void CFidelixToolsView::AssertValid() const
{
	CFormView::AssertValid();
}

void CFidelixToolsView::Dump(CDumpContext& dc) const
{
	CFormView::Dump(dc);
}

CFidelixToolsDoc* CFidelixToolsView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CFidelixToolsDoc)));
	return (CFidelixToolsDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CFidelixToolsView message handlers

void CFidelixToolsView::OnChangeCommandEdit() 
{
	// TODO: If this is a RICHEDIT control, the control will not
	// send this notification unless you override the CFormView::OnInitDialog()
	// function and call CRichEditCtrl().SetEventMask()
	// with the ENM_CHANGE flag ORed into the mask.
	
	// TODO: Add your control notification handler code here

	CString			ATstr, tmpstring, tmpstring1;
	int				i;
	int				len;

	m_command.GetWindowText( ATstr );
	len = strlen( ATstr );

	if( len > 0 )	//have one or more bytes
	{
		if( ATstr.GetAt( len - 1 ) == 0x3E )
		{
			ATstr.SetAt( ( len - 1 ), 0x0D );

			if( pserialthread->m_Serial.m_bOpened == TRUE )		//port is opened
			{
				pserialthread->m_Serial.SendData( ATstr );

//				CTime T1 = CTime::GetCurrentTime();
//				CString time = T1.Format( "[%m-%d %H:%M:%S]" );

//				m_msg_send.GetWindowText( tmpstring );
//				tmpstring += time.Left( strlen( time ) );
//				tmpstring += mascstr.Left( strlen( mascstr ) );
//				m_msg_send.SetWindowText( tmpstring );

//				i = m_msg_send.GetLineCount();
//				if( i > 10 )
//					m_msg_send.LineScroll( i, 0 );
			}
			else
			{
				tmpstring1 = "\r\n";

				CTime T1 = CTime::GetCurrentTime();
				CString time = T1.Format( "[%m-%d %H:%M:%S]" );

				m_message.GetWindowText( tmpstring );
				tmpstring += tmpstring1.Left( strlen( tmpstring1 ) );
				tmpstring += time.Left( strlen( time ) );
//				tmpstring += tmpstring1.Left( strlen( tmpstring1 ) );
				tmpstring += ATstr.Left( strlen( ATstr ) - 1 );
				tmpstring1 = " --- send failure!\r\n";
				tmpstring += tmpstring1.Left( strlen( tmpstring1 ) );
				m_message.SetWindowText( tmpstring );

				i = m_message.GetLineCount( );
				m_message.LineScroll( i, 0 );
			}
			tmpstring = "";
			m_command.SetWindowText( tmpstring );
		}
	}
}

void CFidelixToolsView::OnComOpen() 
{
	// TODO: Add your command handler code here
	pserialthread->m_Serial.Open();
	pserialthread->m_Serial.SetRcvEvent(1);
	pserialthread->m_Serial.SetRTSEnable(1);
	pserialthread->m_Serial.SetBuffCount( 1024, 1024 );

	memset( RcvCommBuf, 0, sizeof( RcvCommBuf ) );	

	SetTimer( 1, 10, NULL );
}

void CFidelixToolsView::OnTimer(UINT nIDEvent) 
{
	// TODO: Add your message handler code here and/or call default
	int				RcvCommTmp, i;
	unsigned char	ATlen;
	unsigned char * ATbuff;
	CString			Showstr, tmpstr, ATstr;

//	check serial receive
	if( pserialthread->m_Serial.m_bOpened )	//port opened
	{
		RcvCommTmp	= RcvCommHead;
		ATlen		= 0;
		Showstr		= "";
		while( RcvCommTmp != RcvCommTail )
		{
			if( RcvCommBuf[ RcvCommTmp ++ ] == 0x0d )	//CR is the end of AT command
			{
				ATlen ++;
				RcvCommTmp %= MAXCOMBUF;

				ATbuff = ( unsigned char * )malloc( ATlen );

				for( int j = 0; j < ATlen; j ++ )
				{
					*( ATbuff + j ) = RcvCommBuf[ RcvCommHead ++ ];
				}
				RcvCommHead = RcvCommTmp;
				Showstr		= ATbuff;

				Showstr	= Showstr.Left( ATlen );
				Showstr.MakeUpper( );
//				ATlen  = strlen( Showstr );
				free( ATbuff );

				m_message.GetWindowText( tmpstr );
				tmpstr += Showstr.Left( strlen( Showstr ) );
				m_message.SetWindowText( tmpstr );

				i = m_message.GetLineCount();
				m_message.LineScroll( i, 0 );

//AT command process
				AT_command_process( Showstr );
				break;
			}
			else
			{
				ATlen ++;
				RcvCommTmp %= MAXCOMBUF;
			}
		}
	}

//check serial send
	if( m_test_flag == TRUE )
	{
		if( pserialthread->m_Serial.m_bOpened )
		{
			switch( m_test_phase )
			{
				case CHECK_AT:
					ATstr = "AT\r";
					pserialthread->m_Serial.SendData( ATstr );
					m_test_count = TIMEOUT;
					m_test_phase ++;
					break;
				case CHECK_RSSI:
					ATstr = "AT$fxrssi\r";
					pserialthread->m_Serial.SendData( ATstr );
					m_test_count = TIMEOUT;
					m_test_phase ++;
					break;
				case CHECK_USTS:
					ATstr = "AT$fxusts\r";
					pserialthread->m_Serial.SendData( ATstr );
					m_test_count = TIMEOUT;
					m_test_phase ++;
					break;
				case CHECK_IMSI:
					ATstr = "AT$FXRDIM=0\r";
					pserialthread->m_Serial.SendData( ATstr );
					m_test_count = TIMEOUT;
					m_test_phase ++;
					break;
				case CHECK_NAM:
					ATstr = "AT$FXRDNI=0\r";
					pserialthread->m_Serial.SendData( ATstr );
					m_test_count = TIMEOUT;
					m_test_phase ++;
					break;
				case CHECK_TIME:
					ATstr = "AT$FXTIME\r";
					pserialthread->m_Serial.SendData( ATstr );
					m_test_count = TIMEOUT;
					m_test_phase ++;
					break;
				case CHECK_VER:
					ATstr = "AT+GMR\r";
					pserialthread->m_Serial.SendData( ATstr );
					m_test_count = TIMEOUT;
					m_test_phase ++;
					break;
				case CHECK_NET:
					ATstr = "AT$FXRNET\r";
					pserialthread->m_Serial.SendData( ATstr );
					m_test_count = TIMEOUT;
					m_test_phase ++;
					break;
				case CHECK_ROAM:
					ATstr = "AT$FXROAM\r";
					pserialthread->m_Serial.SendData( ATstr );
					m_test_count = TIMEOUT;
					m_test_phase ++;
					break;
				case CHECK_ID:
					ATstr = "AT+GMM\r";
					pserialthread->m_Serial.SendData( ATstr );
					m_test_count = TIMEOUT;
					m_test_phase ++;
					break;
				case CHECK_MI:
					ATstr = "AT+GMI\r";
					pserialthread->m_Serial.SendData( ATstr );
					m_test_count = TIMEOUT;
					m_test_phase ++;
					break;
//				case 3:
//					m_test_flag		= FALSE;
//					m_test_count	= 0;
//					m_test_phase	= 0;
//					break;
				default:
					if( m_test_count != 0 )
						m_test_count --;
					else
					{
						m_test_flag		= FALSE;
						m_test_count	= 0;
						m_test_phase	= 0;

						MessageBox( "Connect time out and Testing is terminated!", "Information", MB_OK );
					}					
			}
		}
	}

	CFormView::OnTimer(nIDEvent);
}

void CFidelixToolsView::OnComClose() 
{
	// TODO: Add your command handler code here
	pserialthread->m_Serial.SetRcvEvent(0);
	pserialthread->m_Serial.SetRTSEnable(0);

	pserialthread->m_Serial.Close();

	KillTimer( 1 );
}

int CFidelixToolsView::AT_command_process( CString ATcom )
{
	int		result;
//	CString	RSSI, USTS;

	result = 0;

	if( ( ( ATcom.Find( "OK" ) ) != -1 )&&( ( strlen( ATcom ) < 5 ) ) )	//find OK
	{
		if( m_test_phase == WAIT_AT )
			m_test_phase ++;
		return( 0 );				//0 --- OK
	}
	if( ATcom.Find( "AT" ) != -1 )	//find "AT"
	{

		return( 1 );
	}
	if( ( ATcom.Find( "+" ) != -1 ) || ( ATcom.Find( "$" ) != -1 ) || ( ATcom.Find( "ERROR" ) != -1 ) )	//find "$" or "error"
	{
		switch( m_test_phase )
		{
			case WAIT_RSSI:
//				if( ATcom.Find( "RSSI" ) != -1 )
				if( ( ATcom.Find( "RSSI" ) != -1 ) || ( ATcom.Find( "ERROR" ) != -1 ) )
				{
					RSSIstr	= ATcom;
					m_test_phase ++;
				}
				break;
			case WAIT_USTS:
				if( ATcom.Find( "USTS" ) != -1 )
				{
//					ATcom.Delete( 0, 9 );
//					ATcom.Delete( 1, 1 );
					USTSstr	= ATcom;
					m_test_phase ++;
				}
				break;
			case WAIT_IMSI:
				if( ( ATcom.Find( "RDIM" ) != -1 ) || ( ATcom.Find( "ERROR" ) != -1 ) )
				{
					IMSIstr	= ATcom;
					m_test_phase ++;
				}
				break;
			case WAIT_NAM:
				if( ( ATcom.Find( "RDNI" ) != -1 ) || ( ATcom.Find( "ERROR" ) != -1 ) )
				{
					NAMstr	= ATcom;
					m_test_phase ++;
				}
				break;
			case WAIT_TIME:
				if( ATcom.Find( "TIME" ) != -1 )
				{
					TIMEstr	= ATcom;
					m_test_phase ++;
				}
				break;
			case WAIT_VER:
				if( ATcom.Find( "+GMR" ) != -1 )
				{
					VERstr	= ATcom;
					m_test_phase ++;
				}
				break;
			case WAIT_NET:
				if( ATcom.Find( "NET" ) != -1 )
				{
					NETstr	= ATcom;
					m_test_phase ++;
				}
				break;
			case WAIT_ROAM:
				if( ATcom.Find( "ROAM" ) != -1 )
				{
					ROAMstr	= ATcom;
					m_test_phase ++;
				}
				break;
			case WAIT_ID:
				if( ATcom.Find( "+GMM" ) != -1 )
				{
					IDstr	= ATcom;
					m_test_phase ++;
				}
				break;
			case WAIT_MI:
				if( ATcom.Find( "+GMI" ) != -1 )
				{
					MIstr	= ATcom;
					m_test_phase ++;
//finish the testing
					m_test_flag		= FALSE;
					m_test_count	= 0;
					m_test_phase	= 0;
				}
				break;

			default:
				break;
		}
		return( 2 );
	}
	return( -1 );					//unknown AT command
}


void CFidelixToolsView::OnTestBegin() 
{
	// TODO: Add your command handler code here
	if( pserialthread->m_Serial.m_bOpened )
	{
		if( m_test_flag == TRUE )
		{
			MessageBox( "Testing has started now!", "Information", MB_OK );
		}
		else
		{
			m_test_flag		= TRUE;
			m_test_count	= 5;
			m_test_phase	= 0;
		}	
	}
	else
	{
		MessageBox( "Please open serial port first!", "Information", MB_OK );
	}
}

void CFidelixToolsView::OnTestStop() 
{
	// TODO: Add your command handler code here
	m_test_flag		= FALSE;
	m_test_count	= 0;
	m_test_phase	= 0;

	RSSIstr			= "";
}

void CFidelixToolsView::OnTestReport() 
{
	// TODO: Add your command handler code here
	CString		Resultstr, tmpstr;

	TestingReport	TestingReport;
	if( RSSIstr == "" )
	{
		TestingReport.m_analyze = "No data to analyzed!";
	}
	else
	{
		Resultstr 	= "Start the data analyzing!......\r\n";
		tmpstr		= RSSIstr;
		tmpstr.Delete( 0, 9 );
		tmpstr.Delete( ( tmpstr.GetLength() -1 ), 1 );
		
	}
	TestingReport.DoModal();
}