#include <signal.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#define ACQ_EXTERNAL_DATA
#include "acqdef.h"			/* define shared memory */
#undef ACQ_EXTERNAL_DATA
#include "evtusr.h"			/* Evtmgr events	*/
#include "rtcdef.h"			/* rtcHostComm struct	*/
#include "cpuConfig.h"
#if defined(Force)
#include </usr/sky/bolt2/host/inc/burst_services.h>
#include </usr/sky/bolt2/host/inc/skyprotos.h>
#include </usr/sky/bolt2/host/inc/hostprotos.h>
#elif defined(Themis)
#include </usr/sky/bolt/host/inc/burst_services.h>
#include </usr/sky/bolt/host/inc/skyprotos.h>
#include </usr/sky/bolt/host/inc/hostprotos.h>
#endif

/************************************************************************
* rtc_host.c --
*
* Host-side component of rtc split application.
* The Bolt-side program rtc860 can be run stand-alone, but it will
*  not see any events, nor can it receive a fault-reset command.
*
* History:
*  25-May-2000  TRG  Minor change for conversion to gnu fortran.
*  11-Aug-1999  TRG  Create.
*
************************************************************************/


		/*======================================================
		 * Defines, etc ...
		 *=====================================================*/
#if defined(Force)
#elif defined(Themis)
#define apv2hv_map(P,L)  apv2hv(P)
#endif

#define CMD_HELP        1
#define CMD_EXIT        2
#define CMD_RESET       3


		/*======================================================
		 * Static variables ...
		 *=====================================================*/
static int   boltFlag;
static int   idlFlag;		// set if running from IDL uif
static int   calledViaMain;	/* Non-zero if called via "main"	*/
static struct cmd_struct  cmdList[8] = {
            0,        (void *)(sizeof(cmdList)/sizeof(cmdList[0]))
           ,CMD_HELP,             "?"
           ,CMD_HELP,             "HELP"
           ,CMD_EXIT,             "EXIT"
           ,CMD_EXIT,             "QUIT"
           ,CMD_RESET,            "RESET"
           };
static struct rtcHostComm  *rm;	/* Reserved mem host/bolt communications */



	/***************************************************************
	 * exitHandler:
	 ***************************************************************/
static void  exitHandler( void )
   {
    char  *p;

    p = boltdetach_all();
    printf("\n");
    if (p)
        pcsmsg(0,p);
    pcsmsg(0,"*EXIT*\n");
    exit(0);
   }


static void resetHandler()
   {
   signal(SIGUSR2,resetHandler);
   printf("--> RESET\n");
   rm->nreset = 1;
   return;
   
   }

	/***************************************************************
	 * boltHandler:
	 ***************************************************************/
static int   boltHandler()
   {
    boltFlag = 1;
    return(0);
   }



	/***************************************************************
	 * boltHasExited:
	 ***************************************************************/
static int   boltHasExited()
   {
    pcsmsg(0,"boltHasExited: *EXIT*");
    exitHandler();
   }



	/***************************************************************
	 * arge_set:
	 * Set environment variable in "arge[]" format ...
	 ***************************************************************/
static char  *arge_set( char *name )
   {
    int   nbytes;
    char  *cval;
    char  *p;

    cval = getenv(name);
    nbytes = strlen(name) + 1 + strlen(cval) + 1;
    p = malloc(nbytes);
    sprintf(p,"%s=%s",name,cval?cval:"");
    return(p);
   }



	/***************************************************************
	 * rtcHelp:
	 ***************************************************************/
static void  rtcHelp()
   {
    static char  txt1[] = "\n\
Commands:\n\
    HELP           That's this command\n\
    EXIT/QUIT      More elegant than Ctl-C\n\
    RESET          Request 'fault-reset' in rtc860\n\
\n";
    printf(txt1);
    return;
   }



	/****************************************************************
	 * idl_psrtc:
	 * Return temperatures etc to idl user interface ...
	 ****************************************************************/
int   idl_psrtc( int argc , void *argv[] )
   {
    return(1);
   }



	/***************************************************************
	 * doMain:
	 ***************************************************************/
static int   doMain()
   {
    int   i,k;
    int   opt;
    char  *p;
    char  inbuf[4];
    static int   fd;
    static int   firsttime=1;
    static DYNAMIC_DESCRIPTOR(dsc);

    if (firsttime)
       {
        firsttime = 0;
        siginterrupt(SIGUSR1,0);	//restart
        signal(SIGUSR2,resetHandler);	//restart psrtc
       
       }
    getString("Cmd>",&dsc,0);
    p = dsc.dscA_pointer;
    printf("\n\n");  fflush(stdout);
    msecDelay(500);
    opt = cmd_lookup(&p,cmdList,0,0,0);
    switch(opt)
       {
        default:
            pscExit(0,"Error from cmd_lookup?");

        case CMD_EXIT:
            exitHandler();

        case 0:
        case CMD_HELP:
            rtcHelp();
            break;

        case CMD_RESET:
            printf("--> RESET\n");
            rm->nreset = 1;
            break;
       }
    return(1);
   }



	/***************************************************************
	 * generic_main:
	 ***************************************************************/
int   generic_main(
    int   argc
   ,char  *argv[]
   ,char  *arge[]
   )
   {
    int   k;
    int   argcBolt;
    int   pid;
    int   sts;
    char  *argvBolt[10];
    char  nexusTxt[80];
    char  *p;
    char  **argeBolt;
    char  boltApplication[80];

  for (k=0 ; k<argc ; k++)
    printf("   argv[%d] = %s\n",k,argv[k]);
  printf("\n");

		/*=======================================================
		 * Set program name, setup ctl-c handler ...
		 *======================================================*/
    set_pgmname(argv[0]);
    ctlc_handler(exitHandler);

		/*========================================================
		 * Start up rtc860 program ...
		 *=======================================================*/
    p = strrchr(argv[0],'/');
    if (k = p ? (p-argv[0] + 1) : 0)
        strncpy(boltApplication,argv[0],k);
    strcpy(boltApplication+k,"rtc860");
    sprintf(nexusTxt,NEXUS_FMT,cpuNSTX.rtc.board,
        cpuNSTX.rtc.platform,cpuNSTX.rtc.ap);
    argcBolt = 0;
    argvBolt[argcBolt++] = argv[0];
    argvBolt[argcBolt++] = boltApplication;
    argvBolt[argcBolt++] = nexusTxt;
    for (k=1 ; k<argc ; k++)
       {
        if (!strcmp(argv[k],"-nohcs"))
           {
            strcat(boltApplication,"_nohcs");
            printf("--> running boltApplication %s\n",boltApplication);
           }
        else if (!strcmp(argv[k],"-idl"))
           {
            idlFlag = 1;
           }
	else
            argvBolt[argcBolt++] = argv[k];
       }
    if (calledViaMain)
        argeBolt = arge;
    else
       {
        argeBolt = malloc(10 * sizeof(char *));
        k = 0;
        argeBolt[k++] = arge_set("BOLTuserdata");
        argeBolt[k++] = arge_set("MACHINE");
        argeBolt[k++] = arge_set("PSC_ROOT");
        argeBolt[k++] = arge_set("RTC_INPUT");
        argeBolt[k++] = 0;

        for (k=0 ; ; k++)
           {
            printf("   argeBolt[%d] = %s\n",k,
                argeBolt[k] ? argeBolt[k] : "-null-");
            if (!argeBolt[k])
                break;
           }
       }

    pid = parse_and_boltattach (argcBolt, argvBolt, argeBolt);
			/* NOTE: this blocks signals from all bolts	*/
    if (!pid)
       {
        perror("parse_and_boltattach");
        exitHandler();
       }

		/*=======================================================
		 * Establish bolt signal handlers.
		 * Unblock signal delivery ...
		 *======================================================*/
    host_signal(NOTIFY,boltHandler);
    host_signal(BOLT_EXIT,boltHasExited);

    printf("--> Waiting for notification from bolt ...\n");
    unblock_bolt_signals();
    for (k=0 ; !boltFlag ; k++)
        ;			/* Wait for NOTIFY from Bolt ...	*/
    printf("--> Host:  pid %04X is ready on bolt (k=%d)\n",pid,k);
    rm = (void *)get_share_mem_addr();

    if (idlFlag)
       {
        pcsmsg(0,"running IDL version\n\n");
        return(1);
       }

    for ( ; ; )
        doMain();
   }



	/****************************************************************
	 * main:
	 * Call generic_main for compatibility with idl user interface
	 ****************************************************************/
main( int argc , char *argv[] , char *arge[] )
   {
    calledViaMain = 1;
    generic_main(argc,argv,arge);
   }