#if !BASIC_BIOS

#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include "cli.h"
#include "node.h"
#include "uart.h"

static CommandNode CLI_Head =
{
    "-head-",               // node command hint pointer
    NULL,                   // node command help pointer
    NULL,                   // node current input buffer pointer
    NULL,                   // down leaf pointer
    NULL,                   // right leaf pointer
    COMMAND_TYPE_KEY,       // node type
    NULL                    // node command value
};

char CLI_CmdBuffer[COMMAND_PARA_NUM][COMMAND_PARA_LEN] = { 0 };
const char *hint = "Command>";

void CLI_MAIN( void )
{
    unsigned char key;

    CLI_AddCommandLine( CLI_ShowHelp );

    CLI_AddCommandLine( CLI_ShowDate );
    CLI_AddCommandLine( CLI_ShowTime );
    CLI_AddCommandLine( CLI_ShowHardware );
    CLI_AddCommandLine( CLI_ShowSoftware );
    CLI_AddCommandLine( CLI_ShowBaudrate );
    CLI_AddCommandLine( CLI_ShowIp );

    CLI_AddCommandLine( CLI_SetTime );
    CLI_AddCommandLine( CLI_SetDate );
    CLI_AddCommandLine( CLI_SetIpAddress );
    CLI_AddCommandLine( CLI_SetMac );
    CLI_AddCommandLine( CLI_SetBaudrate );

    CLI_AddCommandLine( CLI_LoadTftp );
    CLI_AddCommandLine( CLI_LoadXmodem );
    CLI_AddCommandLine( CLI_LoadPatTftp );
    CLI_AddCommandLine( CLI_LoadPatXmodem );

    CLI_AddCommandLine( CLI_LoadBasicBiosTftp );
    CLI_AddCommandLine( CLI_LoadBasicBiosXmodem );
    CLI_AddCommandLine( CLI_LoadExtendBiosTftp );
    CLI_AddCommandLine( CLI_LoadExtendBiosXmodem );

    CLI_AddCommandLine( CLI_BackupTftp );
    CLI_AddCommandLine( CLI_BackupXmodem );

    CLI_AddCommandLine( CLI_Copy );

    CLI_AddCommandLine( CLI_Reboot );
    CLI_AddCommandLine( CLI_Run );
    CLI_AddCommandLine( CLI_Go );
    CLI_AddCommandLine( CLI_ReadMemory );
    CLI_AddCommandLine( CLI_WriteMemory );
    CLI_AddCommandLine( CLI_DisplayMem );

    //CLI_ListTree( &CLI_Head, 0 );

    for( ; ; )
    {
        for( key = 0; key < COMMAND_PARA_NUM; key++ )
        {
            CLI_CmdBuffer[ key ][ 0 ] = '\0';
        }
        //memset( CLI_CmdBuffer, 0, COMMAND_PARA_NUM*COMMAND_PARA_LEN );

        UART_Printf((const char*)"\r\n%s", hint );

        if( !CLI_GetCommandLine( &key ) )
        {
            continue;
        }

//            UART_Printf("\nCommand key : %d\n", key );

//            i = 0;
//            for( ;CLI_CmdBuffer[ i ][ 0 ] != '\0'; i++ )
//                puts( CLI_CmdBuffer[ i ] );

//            if( CLI_GetCommandKey( 0 ) != NULL )
//            {
//                if( CLI_GetCommandName( 0 ) != NULL )
//                {
//                    UART_Printf("\n" );
//                    UART_Printf("Command key : %d\n", i );
//                    UART_Printf("Command name: %s\n", CLI_GetCommandName( 0 ));
//                    UART_Printf("Command para: %s\n", CLI_GetCommandKey( 0 ));
//                }
//            }

        switch( key )
        {
            case CLI_BACKWORD:
                UART_Printf("\r\nbackword");
                break;

            case CLI_FORWORD:
                UART_Printf("\r\nforword");
                break;

            case CLI_SHOWDATE:
            case CLI_SHOWTIME:
            case CLI_SHOWHARDWARE:
            case CLI_SHOWSOFTWARE:
            case CLI_SHOWBAUDRATE:
            case CLI_SHOWIP:
            case CLI_SHOWHELP:
                CLI_ShowProc( key );
                break;

            case CLI_SETTIME:
            case CLI_SETDATE:
            case CLI_SETIPADDRESS:
            case CLI_SETMAC:
            case CLI_SETBAUDRATE:
                CLI_SetProc( key );
                break;

            case CLI_LOADTFTP:
            case CLI_LOADXMODEM:
            case CLI_LOADPATTFTP:
            case CLI_LOADPATXMODEM:
            case CLI_LOADBASICXMODEM:
            case CLI_LOADBASICTFTP:
            case CLI_LOADECTENDXMODEM:
            case CLI_LOADEXTENDTFTP:
                CLI_LoadProc( key );
                break;

			case CLI_BACKUPTFTP:
			case CLI_BACKUPXMODEM:
				CLI_BackupProc( key );
				break;

            case CLI_COPY:
                CLI_CopyProc();
                break;

            case CLI_RUN:
            case CLI_GO:
            case CLI_REBOOT:
            case CLI_READMEMORY:
            case CLI_WRITEMEMORY:
            case CLI_DISPMEM:
                CLI_SystemProc( key );
                break;
        }
    }
}

unsigned char CLI_GetCommandLine( unsigned char *command )
{
    unsigned char line = 0, bakkey = 0;
    unsigned long pos = 0;
    char *str; //[COMMAND_PARA_LEN] = { 0 };
    signed short key, k;
    unsigned char process = 1;

    CommandNode *nownode = NULL;
    CommandNode *ptmp = NULL;

    *command = 0;

    nownode = &CLI_Head;
    for( ; process == 1; )
    {
        if( bakkey != 0 )
        {
			key = bakkey;
			bakkey = 0;
		}
		else
		{
			if( UART_kbhit( COM0 ))
			{
		    	key = (unsigned char)UART_getchar( COM0 );
		    }
		    else
		    {
#if !BASIC_BIOS
				OSTimeDly(1);
#endif		    
		    	continue;
		    }
		}
lp:		
        switch( tolower( key ) )
        {
            case K_CTRL_W:
                *command = CLI_BACKWORD;
                return 1;

            case K_CTRL_X:
                *command = CLI_FORWORD;
                return 1;

            case K_ESC:
                process = 0;
                break;

            case '?':
                if( nownode == NULL )
                    break;

                if( nownode->Type == COMMAND_TYPE_KEY )
                {
                    ptmp = CLI_SearchFirst( nownode, CLI_CmdBuffer[line], SEARCH_PART );
                }
                else
                {
                    if( nownode->Input == NULL )
                    {
                        UART_Printf( "\r\n[ " );
                        UART_Printf( "String " );
                        UART_Printf( "]\r\n" );

                        for( k = 0; k < line; k++ )
                        {
                            UART_Printf( "%s ", CLI_CmdBuffer[k] );
                        }

                        if( pos != 0 )
                        {
                            UART_Printf( "%s", CLI_CmdBuffer[k] );
                            pos = strlen( CLI_CmdBuffer[k] );
                        }

                        break;
                    }
                    else
                    {
                        ptmp = CLI_SearchFirst( nownode, "", SEARCH_PART );
                    }
                }

                UART_Printf( "\r\n[ " );

                for( ;ptmp != NULL; )
                {
                    UART_Printf( "\r\n%-15s", ptmp->CmdKey );

                    if( ptmp->Help != NULL )
                    {
                        UART_Printf( ":%s ", ptmp->Help );
                    }

                    ptmp = CLI_SearchNext( ptmp, CLI_CmdBuffer[line], SEARCH_PART );
                }

                UART_Printf( "\r\n]\r\n" );
                UART_Printf("\r\n%s", hint );

                for( k = 0; k < line; k++ )
                {
                    UART_Printf( "%s ", CLI_CmdBuffer[k] );
                }

                if( pos != 0 )
                {
                    UART_Printf( "%s", CLI_CmdBuffer[k] );
                    pos = strlen( CLI_CmdBuffer[k] );
                }
                break;

            case K_ENTER:
                if( nownode == NULL )
                {
                    return 0;
                }

                if( CLI_CmdBuffer[0][0] == '\0' )
                {
                    return 0;
                }
                
                if( CLI_CmdBuffer[line][0] == '\0' )
                {
                    if( nownode->Type == COMMAND_TYPE_KEY )
                    {
                        ptmp = CLI_SearchFirst( nownode, CLI_CmdBuffer[line], SEARCH_PART );
                    }
                    else
                    {
                        if( nownode->Input != NULL )
                        {
                            ptmp = CLI_SearchFirst( nownode, "", SEARCH_PART );
                        }
                    }

                    if( ptmp == NULL )
                    {
                        return 1;
                    }
                }
                else
                {
                	key = ' ';
                	goto lp;
                }

                break;

            case ' ':
                if( CLI_CmdBuffer[line][0] == '\0' )
                {
                    continue;
                }

                ptmp = CLI_SearchFirst( nownode, CLI_CmdBuffer[line], SEARCH_FULL );

                if( ptmp != NULL )
                {
                    nownode = ptmp;
                }
                else
                {
                    ptmp = CLI_SearchFirst( nownode, CLI_CmdBuffer[line], SEARCH_PART );

                    if( ptmp == NULL )
                        continue;

                    ptmp = CLI_SearchNext( ptmp, CLI_CmdBuffer[line], SEARCH_PART );

                    if( ptmp == NULL )
                    {
                        nownode = CLI_SearchFirst( nownode, CLI_CmdBuffer[line], SEARCH_PART );
                    }
                    else
                    {
                        //nownode = ptmp;
                        break;
                    }
                }

                UART_Printf( "%s ", &nownode->CmdKey[pos] );
                strcpy( CLI_CmdBuffer[line++], nownode->CmdKey );
                pos = 0;

                if( nownode->CmdValue != NULL )
                {
                    *command = nownode->CmdValue;
                }

                if( nownode->Type != COMMAND_TYPE_KEY )
                {
               		str = CLI_CmdBuffer[ line ];
                    if( CLI_GetLine( str, COMMAND_PARA_LEN, 0, nownode->Type, &bakkey ))
                    {
                        //strcpy( CLI_CmdBuffer[ line ], str );
                        nownode->Input = CLI_CmdBuffer[ line ];
                        line++;
                        UART_putchar( 0, ' ');
                        //str[0] = '\0';
                    }
                    else
                    {
                        nownode->Input = NULL;
                    }
                }
                break;

            case '\b':
                if( pos > 0 )
                {
                    CLI_CmdBuffer[ line ][ pos-1 ] = '\0';
                    pos--;
                    UART_putchar( 0, '\b' );
                    UART_putchar( 0, ' ' );
                    UART_putchar( 0, '\b' );
                    break;
                }

                if( line == 0 )
                {
                    break;
                }

                line--;
                pos = strlen( CLI_CmdBuffer[line] );
                UART_putchar( 0, '\b' );
                UART_putchar( 0, ' ' );
                UART_putchar( 0, '\b' );

                if( nownode->Input != NULL )
                {
                    strcpy( str, nownode->Input );
                    nownode->Input = NULL;

                    pos = strlen( str );
                    str = CLI_CmdBuffer[ line ];
                    if( CLI_GetLine( str, COMMAND_PARA_LEN, (unsigned char)pos, nownode->Type, &bakkey ))
                    {
                        //strcpy( CLI_CmdBuffer[ line ], str );
                        nownode->Input = CLI_CmdBuffer[ line ];
                        line++;
                        pos = 0;
                        UART_putchar( 0, ' ' );
                        break;
                    }
                    else
                    {
                        line--;
                        pos = strlen( CLI_CmdBuffer[line] );
                        UART_putchar( 0, '\b');
                    }
                }

                nownode = CLI_SearchFirst( &CLI_Head, CLI_CmdBuffer[0], SEARCH_FULL );
                if( nownode != NULL )
                {
                    for( k = 1; k <= line; k++ )
                    {
                        if( nownode->Input != NULL )
                        {
                            k++;
                        }

                        if( CLI_CmdBuffer[k+1][0] != '\0')
                        {
                            ptmp = CLI_SearchFirst( nownode, CLI_CmdBuffer[line], SEARCH_FULL );

                            if( ptmp != NULL )
                            {
                                nownode = ptmp;
                            }
                            else
                            {
                                nownode = CLI_SearchFirst( nownode, CLI_CmdBuffer[k], SEARCH_FULL );
                            }
                        }
                        else
                        {
                            break;
                        }

                        if( nownode == NULL )
                            break;
                    }
                }

                if( line == 0 )
                {
                    nownode = &CLI_Head;
                    break;
                }

                break;

            default:
                if( isprint( key ))
                {
                    if( pos >= COMMAND_PARA_LEN )
                        break;

                    CLI_CmdBuffer[ line ][ pos++ ] = (unsigned char)tolower( key );
                    CLI_CmdBuffer[ line ][ pos ] = '\0';
                    UART_putchar( 0, (unsigned char)key );
                }

                break;
         }
    }

    return 0;
}

char *CLI_GetCommandKey( unsigned char num )
{
    unsigned char k, pos = 0;
    CommandNode *nownode = NULL;

    if( num >= COMMAND_PARA_NUM )
    {
        return NULL;
    }

    nownode = &CLI_Head;

    for( k = 0; k < COMMAND_PARA_NUM; k++ )
    {
        nownode = CLI_SearchFirst( nownode, CLI_CmdBuffer[k], SEARCH_FULL );
        if( nownode == NULL )
        {
            return NULL;
        }

        if( nownode->Type != COMMAND_TYPE_KEY )
        {
            k++;

            if( pos == num )
            {
                return CLI_CmdBuffer[ k ];
            }

            pos++;
        }
     }

     return NULL;
}

char *CLI_GetCommandName( unsigned char num )
{
    unsigned char k, pos = 0;
    CommandNode *nownode = NULL;

    if( num >= COMMAND_PARA_NUM )
    {
        return NULL;
    }

    nownode = &CLI_Head;

    for( k = 0; k < COMMAND_PARA_NUM; k++ )
    {
        nownode = CLI_SearchFirst( nownode, CLI_CmdBuffer[k], SEARCH_FULL );
        if( nownode == NULL )
        {
            return NULL;
        }

        if( nownode->Type != COMMAND_TYPE_KEY )
        {
            if( pos == num )
            {
                return CLI_CmdBuffer[ k ];
            }

            k++;
            pos++;
        }
     }