static char AlarmLogger_id[] = "$Header: /usr/tiburon/unix/gui/tmacs/RCS/AlarmLogger.cc,v 1.9 1997/12/12 17:47:36 oreilly Exp $";


/*
$Log: AlarmLogger.cc,v $
Revision 1.9  1997/12/12 17:47:36  oreilly
*** empty log message ***

Revision 1.8  1997/10/03 09:24:46  oreilly
Use local SList iterator

Revision 1.7  97/09/10  08:45:16  08:45:16  oreilly (Thomas C. O'Reilly)
*** empty log message ***

Revision 1.6  97/08/12  14:15:30  14:15:30  oreilly (Thomas C. O'Reilly)
Method to return setup window

Revision 1.5  97/05/30  15:44:10  15:44:10  oreilly (Thomas C. O'Reilly)
*** empty log message ***

Revision 1.4  97/04/30  19:23:35  19:23:35  oreilly (Thomas C. O'Reilly)
Added method to clear all AlarmLists

Revision 1.3  97/04/09  14:10:17  14:10:17  xoreilly
*** empty log message ***

Revision 1.2  96/07/22  10:41:28  10:41:28  oreilly (Thomas C. O'Reilly)
First external release

*/
#include <stdio.h>
#include <stdlib.h>
#include <Xm/Form.h>
#include <Xm/PushB.h>
#include <Xm/Label.h>
#include <Vk/VkSubMenu.h>
#include <Vk/VkErrorDialog.h>
#include "AlarmLogger.h"
#include "TiburonApp.h"

#define dprintf if (debug) fprintf

FlashList::FlashList(AlarmList **alarmLists)
{
  for (int p = 0; p < NPriorityLevels; p++)
    _list[p] = alarmLists[p];
  
  reset();
}


void FlashList::reset()
{
  _listIndex = 0;
  _entryIndex = 0;
  _flashListIndex = 0;
}


Alarm *FlashList::next(Priority *priority, int *index)
{
  if (total() == 0)
    return NULL;

  int startListIndex = _listIndex;
  int startEntryIndex = _entryIndex;
  
  Boolean looped = False;
  
  while (True)
  {
    int itemCount = _list[_listIndex]->itemCount();

    while (_entryIndex < itemCount)
    {
      Alarm *alarm = _list[_listIndex]->alarm(_entryIndex);
      if (flashIt(alarm))
      {
	*priority = (Priority )(_listIndex + 1);
	*index = ++_flashListIndex; 

        /* Next call should start checking at next index */
	_entryIndex++;      
	return alarm;
      }
      
      if (looped && _listIndex == startListIndex && 
	  _entryIndex == startEntryIndex)
      {
        /* Already searched all AlarmLists for a flash entry, haven't
	   found one. */
	reset();
        *priority = NoPriority;
	return NULL;
      }

      _entryIndex++;

    }

    _listIndex++;
    _entryIndex = 0;
    
    if (_listIndex >= NPriorityLevels)
    {
      // Go to first list
      looped = True;	
      _listIndex = 0;
      _flashListIndex = 0;
    }
  }
}


int FlashList::total(Priority priority)
{
  int p = priority - 1;
  int itemCount = _list[p]->itemCount();

  int total = 0;
  
  for (int entryIndex = 0; entryIndex < itemCount; entryIndex++)
  {
    Alarm *alarm = _list[p]->alarm(entryIndex);
    if (flashIt(alarm))
      total++;
  }

  return total;
}


int FlashList::total()
{
  int sum = 0;
  
  for (int p = 0; p < NPriorityLevels; p++)
    sum += total((Priority )(p + 1));

  return sum;
}


Boolean FlashList::flashIt(Alarm *alarm)
{
  if (!alarm->acknowledged())
    return True;
  else
    return False;
}


const char *const AlarmLogger::priority1FlagsMnem = "priority1Flags";
const char *const AlarmLogger::priority2FlagsMnem = "priority2Flags";
const char *const AlarmLogger::priority3FlagsMnem = "priority3Flags";

AlarmLogger::AlarmLogger(const char *name, Widget parent, 
			 SystemAlarms *alarms)
  : DmGuiObject(name, parent)
{
  _flashList = 0;
  _alarmPage = 0;
  
  for (int p = 0; p < NPriorityLevels; p++)
    _alarmPopup[p] = 0;

  _baseWidget = XtCreateWidget(_name, xmFormWidgetClass, parent, NULL, 0);
  installDestroyHandler();
  XtVaSetValues(_baseWidget, XmNresizePolicy, XmRESIZE_ANY, NULL);
  
  _alarmPanel = new AlarmPanel("alarmPanel", _baseWidget);

  XtVaSetValues(_alarmPanel->baseWidget(), 
		XmNleftAttachment, XmATTACH_FORM,
		XmNrightAttachment, XmATTACH_FORM,
		XmNtopAttachment, XmATTACH_FORM,
		XmNbottomAttachment, XmATTACH_FORM,
		NULL);

  _alarmPanel->setButtonCallback(&AlarmLogger::ackButtonCallback, 
				 (XtPointer )this);

  _alarmPanel->show();
  
  XtManageChild(_baseWidget);

  _actionSetupWindow = NULL;

  _alarmSetupWindow = new AlarmSetupWindow("alarmSetup");

  _alarmSetupWindow->
    alarmEditor->setOkCallback(&AlarmLogger::alarmSetupCallback, this);
  
  _alarmSetupWindow->
    alarmEditor->
      setCancelCallback(&AlarmLogger::cancelAlarmSetupCallback, this);

  for (int p = 0; p < NAlarmLists; p++)
  {
    char name[100];
    sprintf(name, "priority%dPopup", p + 1);
    _alarmPopup[p] = new AlarmPopup(name, (Priority )(p + 1));
    _alarmPopup[p]->setOkCallback(&AlarmLogger::alarmPopupCallback, 
				  (XtPointer )this);
  }
  
  TiburonApp *app = (TiburonApp *)theApplication;
  RovMainWindow *rovMainWindow = app->rovMainWindow();
  
  _alarmPageView = rovMainWindow->createView("alarmPageView");

  _alarmPage = new AlarmPage("alarmPage", _alarmPageView->baseWidget(), 
			     _alarmPopup, _alarmSetupWindow);

  _alarmPage->show();
  
  Layout *layout = new Layout();
  layout->attachToEdge(Left);
  layout->attachToEdge(Top);
  layout->attachToEdge(Right);
  layout->attachToEdge(Bottom);
  
  _alarmPageView->add(_alarmPage->baseWidget(), layout);
  
  _alarms = alarms;
  Alarm **alarm;
  SListIter<Alarm *> alarms(_alarms->alarmList);
  
  alarms.reset();
  /* Add alarms' DM items to consumer list */
  while (alarm = alarms.next())
  {
    if (addDmObject((*alarm)->dmObject(), DmConsumeFlag) == -1)
      return; 
  }

  if (setConsumePeriod(Aperiodic) == -1)
    return;

  _flashList = new FlashList(_alarmPage->alarmList);
  
  _alarmLightState = InitState;
  _bellPeriod = 500;
  _bellTimer = 0;
  _labelPeriod = 1000;
  _labelTimer = 0;
  
  _alarmActionBits[priorityIndex(Priority1)] = BeepOnce | StickyAlarms;
  _alarmActionBits[priorityIndex(Priority2)] = BeepOnce | StickyAlarms;  
  _alarmActionBits[priorityIndex(Priority3)] = 0;  
  _alarmActionBits[priorityIndex(NoPriority)] = StickyAlarms;  

  checkAllAlarms(TRUE);
}


AlarmLogger::~AlarmLogger()
{
  delete _flashList;

  for (int p = 0; p < NPriorityLevels; p++)
    delete _alarmPopup[p];

  delete _alarmPage;
}


void AlarmLogger::updateGui(DM_Item handle)
{
  MBool debug = ((TiburonApp *)theApplication)->debug();
  debug = False;
  if (handle == 0)
  {
    return;
  }
  
  // Find alarm object which corresponds to changed dmObject
  Alarm **alarm;
  SListIter<Alarm *> alarms(_alarms->alarmList);
  
  alarms.reset();
  MBool found = FALSE;
  
  while (alarm = alarms.next())
  {
    if ((*alarm)->dmObject()->getHandle() == handle)
    {
      found = TRUE;
      break;
    }
  }
  if (!found)
  {
    fprintf(stderr, 
	    "AlarmLogger::updateGui() - couldn't find Alarm object\n");
    exit(1);
  }

  // Read new alarm value, update alarm state
  (*alarm)->update();

  processAlarm(*alarm);

  updateAlarmPanel();
}



int AlarmLogger::checkAllAlarms(MBool init)
{
  MBool debug = FALSE;
  dprintf(stderr, "checkAllAlarms()... ");

  SListIter<Alarm *> alarms(_alarms->alarmList);
  
  alarms.reset();
  Alarm **alarm;
  
  while (alarm = alarms.next())
  {
    if (init)
      (*alarm)->update();

    processAlarm(*alarm);
  }

  // Sort alarms
  for (int p = 0; p < NAlarmLists; p++)
  {
    _alarmPage->alarmList[p]->sort();
    _alarmPopup[p]->list->sort();
  } 

  updateAlarmPanel();
  
  return 0;
}


void AlarmLogger::processAlarm(Alarm *alarm)
{
  assignToList(alarm);
  execAlarmAction(alarm);
}


void AlarmLogger::updateAlarmPanel()
{
  updateActiveCounts();

  if (_flashList->total())
    flash();
  else
    shine();

}


void AlarmLogger::acknowledge(Priority priority)
{
  int p = priorityIndex(priority);
  
  int itemCount = _alarmPage->alarmList[p]->itemCount();

  for (int i = 0; i < itemCount; i++)
  {
    Alarm *alarm = _alarmPage->alarmList[p]->alarm(i);
    alarm->acknowledge();
  }
  
  if (_alarmActionBits[p] & BeepTilAck)
    stopRinging();
}


void AlarmLogger::ackButtonCallback(Widget w, XtPointer clientData, 
				    XtPointer callData)
{
  Boolean debug = False;
  AlarmLogger *obj = (AlarmLogger *)clientData;
  obj->stopRinging();

  if (obj->_flashList->total())
  {
    // Acknowledge all alarms
    for (int p = 0; p < NAlarmLists; p++)  
      obj->acknowledge((Priority )(p + 1));  

    // Check for active alarms; set button state accordingly
    obj->checkAllAlarms();
  }
  else
  {
    // All alarms are already acknowledged, refresh and display alarm page
    obj->clearLists();
    dprintf(stderr, "ackButtonCallback() - checkAllAlarms() #2\n");
    obj->checkAllAlarms();

    // Display alarm page
    TiburonApp *app = (TiburonApp *)theApplication;
    RovMainWindow *mainWindow = app->rovMainWindow();
    mainWindow->setView(obj->_alarmPageView);
  }
}


void AlarmLogger::flash()
{
  if (_alarmLightState == Flashing)
    return;
  
  _alarmLightState = Flashing;

  updateFlashLabel();
  
  _alarmPanel->flash();

  // Start timer to update flashing label
  if (!_labelTimer)  
    _labelTimer = XtAppAddTimeOut(theApplication->appContext(), _labelPeriod,
				  &AlarmLogger::labelTimerCallback,
				  (XtPointer )this);
}


void AlarmLogger::shine()
{
  _alarmLightState = Shining;

  if (_labelTimer)
  {
    XtRemoveTimeOut(_labelTimer);
    _labelTimer = 0;
  }
  
  char buf[100];

  int total = 0;
  for (int p = 0; p < NPriorityLevels; p++)
  {
    for (int i = 0; i < _alarmPage->alarmList[p]->itemCount(); i++)
    {
      Alarm *alarm = _alarmPage->alarmList[p]->alarm(i);
      if (alarm->active())
	total++;
    }
  }
  
  sprintf(buf, "%d Active Alarm", total);
  if (total > 1)
    strcat(buf, "s");

  _alarmPanel->setLightLabel(buf);
  _alarmPanel->darken();
  _flashList->reset();
}


void AlarmLogger::startRinging()
{
  // Avoid thrashing
  if (bellRinging())
    return;
  
  _bellTimer = XtAppAddTimeOut(theApplication->appContext(), _bellPeriod,
			       &AlarmLogger::bellTimerCallback,
			       (XtPointer )this);
}


void AlarmLogger::stopRinging()
{
  XtRemoveTimeOut(_bellTimer);
  _bellTimer = 0;
}


void AlarmLogger::execAlarmAction(Alarm *alarm)
{
  static time_t prevBeepTime = 0;
  time_t t;

  Priority priority = alarm->priority(alarm->value());
  
  if (alarm->acknowledged() || priority == NoPriority)
    return;

  int p = (int )priority - 1;

  int actionBits = _alarmActionBits[p];

  if (actionBits & BeepOnce)
  {
    t = time(NULL);
    if (t - prevBeepTime > 0)
    {
      XBell(theApplication->display(), XBellLevel);
      prevBeepTime = t;
    }
  }
  
  if ((actionBits & BeepTilAck) && !bellRinging())
    startRinging();

  if (actionBits & PopupList)
  {
    if (!_alarmPopup[p]->visible())
      _alarmPopup[p]->show();

    _alarmPopup[p]->open();
    _alarmPopup[p]->raise();
  }
}


void AlarmLogger::clearLists()
{
  for (int p = 0; p < NAlarmLists; p++)
  {
    _alarmPage->alarmList[p]->clear();
    _alarmPopup[p]->list->clear(); 
  }
}


void AlarmLogger::showActionSetupCallback(Widget w, XtPointer clientData,
					  XtPointer callData)
{
  AlarmLogger *obj = (AlarmLogger *)clientData;

  if (obj->_actionSetupWindow)
  {
    // Already up
    obj->_actionSetupWindow->open();  
    obj->_actionSetupWindow->raise();  
    return;
  }
  
  ActionSetupWindow *setupWindow = obj->_actionSetupWindow = 
    new ActionSetupWindow("actionSetup", 
			  obj->_alarmActionBits); 

  setupWindow->setOkCallback(&AlarmLogger::actionSetupCallback, 
			     (XtPointer )obj);
  setupWindow->
    setCancelCallback(&AlarmLogger::cancelActionSetupCallback, 
		      (XtPointer )obj);

  setupWindow->addDeleteHandler(&AlarmLogger::windowDeleteHandler,
				(XtPointer )obj);
  setupWindow->show();
}


void AlarmLogger::showAlarmSetupCallback(Widget w, XtPointer clientData,
					 XtPointer callData)
{
  AlarmLogger *obj = (AlarmLogger *)clientData;
  obj->_alarmSetupWindow->show();
  obj->_alarmSetupWindow->open();
  obj->_alarmSetupWindow->raise();
}


void AlarmLogger::alarmSetupCallback(Widget w, XtPointer clientData,
				     XtPointer callData)
{
  AlarmLogger *obj = (AlarmLogger *)clientData;
  obj->_alarmSetupWindow->alarmEditor->updateAlarmItem();
  obj->_alarmPage->clear();
  Boolean debug = False;
  dprintf(stderr, "alarmSetupCallback() - checkAllAlarms()\n");
  obj->checkAllAlarms();
}


void AlarmLogger::cancelAlarmSetupCallback(Widget w, XtPointer clientData,
					   XtPointer callData)
{
  AlarmLogger *obj = (AlarmLogger *)clientData;
  obj->_alarmSetupWindow->hide();
}


void AlarmLogger::cancelActionSetupCallback(Widget w, XtPointer clientData,
					    XtPointer callData)
{
  AlarmLogger *obj = (AlarmLogger *)clientData;
  obj->_actionSetupWindow->hide();
  delete obj->_actionSetupWindow;
  obj->_actionSetupWindow = NULL;
}


void AlarmLogger::actionSetupCallback(Widget w, XtPointer clientData,
				XtPointer callData)
{
  AlarmLogger *obj = (AlarmLogger *)clientData;
  obj->_actionSetupWindow->alarmActions(obj->_alarmActionBits);

  // Remove window
  obj->_actionSetupWindow->hide();
  delete obj->_actionSetupWindow;
  obj->_actionSetupWindow = NULL;
}


void AlarmLogger::bellTimerCallback(XtPointer clientData, XtIntervalId *id)
{
  AlarmLogger *obj = (AlarmLogger *)clientData;
  
  XBell(theApplication->display(), XBellLevel);
  
  obj->_bellTimer = XtAppAddTimeOut(theApplication->appContext(), 
				    obj->_bellPeriod,
				    &AlarmLogger::bellTimerCallback,
				    obj);
}


void AlarmLogger::alarmPopupCallback(Widget w, XtPointer clientData,
				     XtPointer callData)
{
  AlarmLogger *obj = (AlarmLogger *)clientData;
  for (int p = 0; p < NAlarmLists; p++)
  {
    if (w == obj->_alarmPopup[p]->okButton())
    {
      obj->_alarmPopup[p]->hide();
      Priority priority = (Priority )(p + 1);
      obj->acknowledge(priority);
      obj->checkAllAlarms();
      break;
    }
  }
}


void AlarmLogger::updateFlashLabel()
{
  MBool debug = FALSE;
  char buf[100];
  
  int total = _flashList->total();
  if (!total)
    return;

  Priority priority;
  int index;
  
  Alarm *alarm = _flashList->next(&priority, &index);

  if (!alarm)
    return;
  
  // Set label
  sprintf(buf, "%s", alarm->itemMnemonic());
      
  if (total > 1)
  {
    char *ptr = buf + strlen(buf);
    sprintf(ptr, "\n%d of %d new", index, total);
  }
      
  _alarmPanel->setLightLabel(buf);

  // Set color
  _alarmPanel->setLightPriority(priority);
  _alarmPanel->flash();

  return;
}


void AlarmLogger::updateActiveCounts()
{
  for (int p = 0; p < NPriorityLevels; p++)
  {
    int total = _alarmPopup[p]->list->itemCount(); 

    Priority priority = (Priority )(p + 1);
    
    _alarmPanel->setCount(priority, total);
  }
}


void AlarmLogger::labelTimerCallback(XtPointer clientData, XtIntervalId *id)
{
  AlarmLogger *obj = (AlarmLogger *)clientData;
  
  obj->updateFlashLabel();
  
  obj->_labelTimer = XtAppAddTimeOut(theApplication->appContext(), 
				     obj->_labelPeriod,
				     &AlarmLogger::labelTimerCallback,
				     obj);
}


void AlarmLogger::windowDeleteHandler(Widget mainWindowWidget, 
				      XtPointer clientData)
{
  MBool debug = FALSE;
  AlarmLogger *obj = (AlarmLogger *)clientData;
  
  if (obj->_alarmSetupWindow && 
      obj->_alarmSetupWindow->mainWindowWidget() == mainWindowWidget)
  {
    dprintf(stderr, 
	    "AlarmLogger::windowDeleteHandler - Setting _alarmSetupWindow "
	    "to NULL...\n");

    obj->_alarmSetupWindow = NULL;
  }
  else if (obj->_actionSetupWindow &&
	   obj->_actionSetupWindow->mainWindowWidget() == mainWindowWidget)
  {
    dprintf(stderr, 
	    "AlarmLogger::windowDeleteHandler - Setting _actionSetupWindow "
	    "to NULL...\n");

    obj->_actionSetupWindow = NULL;
  }
  
}


/*
Assign alarm to list of appropriate priority, or delete it from lists
*/
void AlarmLogger::assignToList(Alarm *alarm)
{
  Priority priority = alarm->priority(alarm->value());
  int p = (int )priority - 1;

  Boolean belongsOnLists = False;

  if (alarm->active() || 
      (alarm->eventAlarm() && !alarm->acknowledged()) || 
      (stickyAlarms(priority) && !alarm->acknowledged()))
  {
    belongsOnLists = True;
  }
  
  int i;
  
  if (belongsOnLists)
  {
    for (i = 0; i < NAlarmLists; i++)
    {
      if (i != p)
      {
	/* Alarm might be on other priority list; if so remove it, unless
	   that other list is sticky */
	if (!stickyAlarms(indexPriority(i)) || 
	    (alarm->acknowledged() || alarm->wasAcknowledged()))
	{
	  _alarmPage->alarmList[i]->remove(alarm);
	  _alarmPopup[i]->list->remove(alarm);
	}
      }
      else if (alarm->value() != alarm->okayValue() || alarm->eventAlarm())
      {
	/* Append alarm to appropriate priority list. First remove it
	 if it's already there. */
	_alarmPage->alarmList[i]->remove(alarm);
	_alarmPopup[i]->list->remove(alarm);
	
	_alarmPage->alarmList[i]->append(alarm);
	_alarmPopup[i]->list->append(alarm);
      }
    }
  }
  else  
  {
    /* Remove alarm from all lists */
    for (i = 0; i < NAlarmLists; i++)
    {
      _alarmPage->alarmList[i]->remove(alarm);
      _alarmPopup[i]->list->remove(alarm);
    }
  }

  return;
}


AlarmSetupWindow *AlarmLogger::setupWindow()
{
  return _alarmSetupWindow;
}


void AlarmLogger::setActionBits(Priority priority, int actionBits)
{
  int p = (int )priority - 1;
  _alarmActionBits[p] = actionBits;
}


int AlarmLogger::getActionBits(Priority priority)
{
  return _alarmActionBits[(int )priority - 1];
}


int AlarmLogger::loadPreferences(DynArray<Preference *> *preferences, 
				 char *errorBuf)
{
  MBool error = FALSE;
  for (int i = 0; i < preferences->size(); i++)
  {
    Preference *preference;
    preferences->get(i, &preference);
    
    if (!strcmp(preference->keyword(), priority1FlagsMnem))
      setActionBits(Priority1, atoi(preference->value()));

    else if (!strcmp(preference->keyword(), priority2FlagsMnem))
      setActionBits(Priority2, atoi(preference->value()));
    
    else if (!strcmp(preference->keyword(), priority3FlagsMnem))
      setActionBits(Priority3, atoi(preference->value()));
  }
  
  return 0;
}


int AlarmLogger::savePreferences(DynArray<Preference *> *preferences, 
				 char *errorBuf)
{
  char buf[100];

  Preference *preference;

  sprintf(buf, "%d", getActionBits(Priority1));
  preference = new Preference(priority1FlagsMnem, buf);
  preferences->add(&preference);

  sprintf(buf, "%d", getActionBits(Priority2));
  preference = new Preference(priority2FlagsMnem, buf);
  preferences->add(&preference);

  sprintf(buf, "%d", getActionBits(Priority3));
  preference = new Preference(priority3FlagsMnem, buf);
  preferences->add(&preference);
  
  return 0;
}