//
//  $Log: ui-shell.c,v $
//  Revision 1.4  1994/10/04  01:13:13  hakan
//  PROGDIR:-Abhängigkeit beseitigt
//
//  Revision 1.3  1994/09/11  11:44:07  hakan
//  Wurx...
//
//  Revision 1.2  1994/07/11  21:58:05  hakan
//  Just used to test src/Timer.c
//
//  Revision 1.1  1994/06/14  20:37:43  hakan
//  Initial revision
//
//

static char* RCSId = "$Id: ui-shell.c,v 1.4 1994/10/04 01:13:13 hakan Exp $";

#include "extern.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;



BOOL CreateUI (int argc, char* argv[])
{
    char* template =
    "O=Owner/S,IP=IP-Addr/S,Kick=Kickstart/S,WB=Workbench/S,NIPC/S,"
    "FM=FastMem/S,CM=ChipMem/S,P=Processor/S,C=Chips/S,S=Services/S,E=Entities/S,"
    "A=All/S,SR=ScanRealms/S,SH=ScanHosts/S,SA=ScanAll/S,SP=ScanPing/K,K=Kludge/S,"
    "SF=SaveFile/K,MT=MaxTime/K/N,MP=MaxPackets/K/N,R=Realms/K/M"
    "";

    args = ReadArgs (template, opts, NULL);


    if (args)
    {
        scanmode = MODE_SCAN_HOSTS;

        if (opts [OPT_ALL])
        {
            opts [OPT_OWNER    ] = 1;
            opts [OPT_IPADDR   ] = 1;
            opts [OPT_KICKSTART] = 1;
            opts [OPT_WORKBENCH] = 1;
            opts [OPT_NIPC     ] = 1;
            opts [OPT_FAST_MEM ] = 1;
            opts [OPT_CHIP_MEM ] = 1;
            opts [OPT_PROCESSOR] = 1;
            opts [OPT_CHIPS    ] = 1;
            opts [OPT_SERVICES ] = 1;
            opts [OPT_ENTITIES ] = 1;
        }

        SetOption (OPT_OWNER,       NP_Owner,       "Owner");
        SetOption (OPT_IPADDR,      NP_IPAddr,      "IPAddr");
        SetOption (OPT_KICKSTART,   NP_KickVersion, "KickVersion");
        SetOption (OPT_WORKBENCH,   NP_WBVersion,   "WBVersion");
        SetOption (OPT_NIPC,        NP_NIPCVersion, "NIPCVersion");
        SetOption (OPT_FAST_MEM,    NP_MaxFastMem,  "MaxFastMem");
        SetOption (OPT_FAST_MEM,    NP_AvailFastMem,"AvailFastMem");
        SetOption (OPT_CHIP_MEM,    NP_MaxChipMem,  "MaxChipMem");
        SetOption (OPT_CHIP_MEM,    NP_AvailChipMem,"AvailChipMem");
        SetOption (OPT_PROCESSOR,   NP_ATTNFlags,   "ATTNFlags");
        SetOption (OPT_CHIPS,       NP_ChipRevBits, "ChipRevBits");
        SetOption (OPT_SERVICES,    NP_Services,    "Services");
        SetOption (OPT_ENTITIES,    NP_Entities,    "Entities");

        if (opts [OPT_KLUDGE])  NP_Config |= NP_402_Kludge;

        SetMode (OPT_SCAN_REALMS, MODE_SCAN_REALMS, "Realms");
        SetMode (OPT_SCAN_HOSTS,  MODE_SCAN_HOSTS,  "Hosts");
        SetMode (OPT_SCAN_ALL,    MODE_SCAN_ALL,    "All");
        SetMode (OPT_SCAN_PING,   MODE_SCAN_PING,   "Ping");
        
        NP_ScanHost = (char*) opts [OPT_SCAN_PING];

        SetNum  (OPT_MAX_TIME,    NP_ScanTime,      "MaxTime");
        SetNum  (OPT_MAX_PACKETS, NP_ScanPackets,   "MaxPackets");

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

        savef = (char*) opts [OPT_SAVEFILE];

        if (!NP_ScanHost)    NP_ScanHost    = "backbone:kahalo";
        if (!NP_ScanTime)    NP_ScanTime    = 1;
        if (!NP_ScanPackets) NP_ScanPackets = 10;
    }
    else
    {
        PrintFault (IoErr(), NULL);
        return (FALSE);
    }

    return (TRUE);
}



void DestroyUI (void)
{
}



void EventLoop (void)
{
    switch (scanmode)
    {
        case MODE_SCAN_REALMS:
            ScanRealms ();
            break;

        case MODE_SCAN_HOSTS:
            if (realms)
            {
                char** r;
                for (r = realms; *r; r++)
                {
                    ScanHosts (*r);
                }
            }
            else
            {
                ScanHosts (NULL);
            }
            break;

        case MODE_SCAN_ALL:
            ScanAll ();
            break;

        case MODE_SCAN_PING:
            NP_Config |= NP_SingleHost;
            ScanPing ();
            break;

        default:
            break;
    }

    Delay (25);

    {
        struct List* h;
        struct List* r;

        h = Hosts();
        r = Realms();

        if ((!IsListEmpty(h)) || (!IsListEmpty(r)))
        {
            printf ("\n");
            SaveList (savef);
        }
    }
}



BOOL OpenScanWindow (long max)
{
    return (TRUE);
}



void CloseScanWindow (void)
{
}



BOOL ShowScan (long current)
{
    int i;

    for (i=0; i<5; i++)
    {
        SendIO (TimeRequest ());

        Wait (1 << TimePort()->mp_SigBit);

        while (GetMsg (TimePort()))
            ;

        printf (".");
        fflush (stdout);
    }

    return (FALSE);
}