//
//  $Log: ui-Shell.c,v $
//  Revision 1.2  1994/03/29  21:24:14  hakan
//  Leistet
//
//  Revision 1.1  1994/02/22  23:51:59  hakan
//  Initial revision
//
//



#include <config.h>
#include <protoypes.h>

#include <ui-Shell.h>


static long             scanmode;
static LONG             opts[OPT_COUNT];
static struct RDArgs*   args        = NULL;
static char**           realms      = NULL;
static char*            savef       = NULL;
static long             ScanRunning = TRUE;



void SetupUI (int argc, char* argv[])
{
    args = ReadArgs (TEMPLATE, opts, NULL);


    if (args = NULL)
    {
        PrintFault (IoErr(), NULL);
        //  Fehler!!!
    }
    else
    {
        scanmode = MODE_SCAN_HOSTS;

        SetOption (OPT_OWNER,       NP_Owner);
        SetOption (OPT_IPADDR,      NP_IPAddr);
        SetOption (OPT_KICKSTART,   NP_KickVersion);
        SetOption (OPT_WORKBENCH,   NP_WBVersion);
        SetOption (OPT_NIPC,        NP_NIPCVersion);
        SetOption (OPT_FAST_MEM,    NP_MaxFastMem);
        SetOption (OPT_FAST_MEM,    NP_AvailFastMem);
        SetOption (OPT_CHIP_MEM,    NP_MaxChipMem);
        SetOption (OPT_CHIP_MEM,    NP_AvailChipMem);
        SetOption (OPT_PROCESSOR,   NP_ATTNFlags);
        SetOption (OPT_CHIPS,       NP_ChipRevBits);
        SetOption (OPT_SERVICES,    NP_Services);
        SetOption (OPT_ENTITIES,    NP_Entities);
        
        if (opts [OPT_ALL])  NP_Configuration |= ((1L << 14) - 1);
        
        if (opts [OPT_KLUDGE]) NP_Configuration |= NP_402_Kludge;

        SetMode (OPT_SCAN_REALMS, MODE_SCAN_REALMS);
        SetMode (OPT_SCAN_HOSTS,  MODE_SCAN_HOSTS);
        SetMode (OPT_SCAN_ALL,    MODE_SCAN_ALL);

        SetNum (OPT_MAX_TIME,    NP_ScanTime);
        SetNum (OPT_MAX_PACKETS, NP_ScanPackets);

        realms = (char**) (opts [OPT_REALMS]);

        savef = (char*) opts [OPT_SAVEFILE];
    }
}




void ShutDownUI (void)
{
    if (args)
    {
        FreeArgs (args);
    }
}



void EventLoop (void)
{
    if (savef)
    {
        printf ("Savefile: %s\n", savef);
    }

    if (realms)
    {
        char** tmp;

        tmp = realms;
        printf ("Realms to scan:\n");
        while (*tmp)
        {
            printf ("    %s\n", (long*) *tmp);
            tmp++;
        }
    }


    switch (scanmode)
    {
        case MODE_SCAN_HOSTS:
            if (realms)
            {
                printf ("Scanning hosts in realm %s\n", *realms);
                ScanHosts (*realms);
            }
            else
            {
                printf ("Scanning hosts\n");
                ScanHosts (NULL);
            }
            break;

        case MODE_SCAN_REALMS:
            printf ("Scanning for realms\n");
            ScanRealms ();
            break;

        case MODE_SCAN_ALL:
            printf ("Scanning all\n");
            ScanAllHosts ();
            break;
    }

    putchar ('.');
    fflush (stdout);
    Delay (25);

    putchar ('.');
    fflush (stdout);
    Delay (25);

    putchar ('\n');
    fflush (stdout);

    SaveList ("CONSOLE:");

    if (savef)
    {
        SaveList (savef);
    }
}



void SetupFuelGauge (long current, long max)
{
}



void ShutDownFuelGauge (void)
{
}



void ShowScan (void)
{
    long ReceivedSignals;
    long ticks      = 0;
    struct timerequest* TimeReq  = GetTimeReq ();
    struct MsgPort*     TimePort = GetTimePort ();



    TimeReq->tr_time.tv_secs    = 0L;
    TimeReq->tr_time.tv_micro   = 500000;
    SendIO ((struct IORequest*) TimeReq);

    while (ScanRunning)
    {
        ReceivedSignals = Wait (SIGBREAKF_CTRL_C | 1L << TimePort->mp_SigBit);


        if (ReceivedSignals & SIGBREAKF_CTRL_C)
        {
            ScanRunning = FALSE;
        }

        if (ReceivedSignals & (1L << TimePort->mp_SigBit))
        {
            if (ticks ++ == NP_ScanTime * 2)
            {
                ScanRunning = FALSE;
            }

            while (GetMsg (TimePort))
                ;

            TimeReq->tr_time.tv_secs    = 0L;
            TimeReq->tr_time.tv_micro   = 500000;
            SendIO ((struct IORequest*) TimeReq);

            putchar ('.');
            fflush (stdout);
        }
    }

    AbortIO ((struct IORequest*) TimeReq);

}



void __regargs _CXBRK (void)
{
    ScanRunning = FALSE;
}