/* Copyright 1999 American Power Conversion, All Rights Reserverd
* 
* Description:
*   The ApcMiniDriver class provides an interface that is
*   compatible with the MiniDriver interface for the Windows2000
*   UPS service.  
*   The ApcMiniDriver makes use of a modified 
*   PowerChute plus UPS service.  This modified service has had
*   all of the networking, data logging, and flex manager code
*   removed.  All that is left is the modeling and monitoring of
*   the connected UPS system.  It is assumed that a "smart" 
*   signalling UPS is connected.
*   The ApcMiniDriver class is also responsible for filling in
*   the advanced registry settings, battery replacement condition,
*   serial #, firmware rev, etc...
*
* Revision History:
*   mholly  14Apr1999  Created
*   mholly  16Apr1999  Convert data from UPS into wide characters
*                       if UNICODE is defined
*   mholly  19Apr1999  remove registry updates of utility line state
*   mholly  20Apr1999  no longer updating model/vendor in registry
*   mholly  26Apr1999  convert RUN_TIME_REMAINING to minutes before
*                       updating the registry - also only update the
*                       runtime in the onRuntimeTimer method
*   mholly  12May1999  no longer taking aCommPort parameter in UPSInit
*
*/

#include "cdefine.h"

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>

#include "apcdrvr.h"
#include "apcups.h"
#include "ntsrvap.h"
#include "event.h"
#include "timerman.h"
#include "codes.h"
#include "tokenstr.h"

extern "C"{
#include "upsreg.h"
}

// Separator used for the shutdown delay allowed values
#define SHUTDOWN_DELAY_SEPARATOR				","
#define LOW_BATT_DURATION_SEPARATOR     ","
#define SECONDS_TO_MINUTES              60

/**
* ApcMiniDriver
*
* Description:
*   Constructor - initializes all data members
*
* Parameters:   
*   None
*
* Returns:
*   N/A
*
*/
ApcMiniDriver::ApcMiniDriver()
: theState(UPS_ONLINE),
  theStateChangedEvent(NULL),
  theReplaceBatteryState(UPS_BATTERYSTATUS_UNKNOWN),
  theUpsApp(NULL),
  theRunTimeTimer(0),
  theOnBatteryRuntime(-1),
  theBatteryCapacity(-1)
{
}


/**
* ~ApcMiniDriver
*
* Description:
*   Destructor - does nothing, must call
*   UPSStop prior to destructor
*
* Parameters:   
*   None
*
* Returns:
*   N/A
*
*/
ApcMiniDriver::~ApcMiniDriver()
{
}


/**
* UPSInit
*
* Description:
*   Must be the first method called on the object
*   Failing to call UPSInit will result in an object
*   in an unstable state
*
* Parameters:   
*   aCommPort: not used
*
* Returns:
*   UPS_INITOK: initalized successfully
*   UPS_INITUNKNOWNERROR: initialization failed
*
*/
DWORD ApcMiniDriver::UPSInit()
{
    DWORD init_err = UPS_INITOK;
	
    theStateChangedEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	
    if (!theStateChangedEvent) {
        init_err = UPS_INITUNKNOWNERROR;
	}
	
    if ((UPS_INITOK == init_err) && 
        (ErrNO_ERROR != initalizeUpsApplication())) {
        init_err = UPS_INITUNKNOWNERROR;
    }

    if (UPS_INITOK != init_err) {
        UPSStop();
    }

    return init_err;
}


/**
* UPSStop
*
* Description:
*   must be called to cleanup the object, after
*   this call completes the only valid method
*   call is UPSInit() or the destructor
*
* Parameters:   
*   None
*
* Returns:
*   None
*
*/
void ApcMiniDriver::UPSStop()
{
    UPSCancelWait();	
    cleanupUpsApplication();
	
    if (theStateChangedEvent) {
        CloseHandle(theStateChangedEvent);
        theStateChangedEvent = NULL;
    }
}


/**
* UPSWaitForStateChange
*
* Description:
*   Blocks until the state of the UPS differs
*   from the value passed in via aState or 
*   anInterval milliseconds has expired.  If
*   anInterval has a value of INFINITE this 
*   function will never timeout
*
* Parameters:
*   aState: defines the state to wait for a change from,
*           possible values:
*           UPS_ONLINE 
*           UPS_ONBATTERY
*           UPS_LOWBATTERY
*           UPS_NOCOMM
*
*   anInterval: timeout in milliseconds, or INFINITE for
*               no timeout interval
*
* Returns:
*   None
*
*/
void ApcMiniDriver::UPSWaitForStateChange(DWORD aLastState, DWORD anInterval)
{	
    if (aLastState == theState) {
        //
        // wait for a state change from the UPS
        //
        if (theStateChangedEvent) {
            WaitForSingleObject(theStateChangedEvent, anInterval);
        }
    }	
}


/**
* UPSGetState
*
* Description:
*   returns the current state of the UPS
*
* Parameters:
*   None
*
* Returns: 
*   possible values:
*           UPS_ONLINE 
*           UPS_ONBATTERY
*           UPS_LOWBATTERY
*           UPS_NOCOMM
*   
*/
DWORD ApcMiniDriver::UPSGetState()
{
    return theState;
}


/**
* UPSCancelWait
*
* Description:
*   interrupts pending calls to UPSWaitForStateChange
*   without regard to timout or state change
*
* Parameters:
*   None
*
* Returns:
*   None
*   
*/
void ApcMiniDriver::UPSCancelWait()
{
    if (theStateChangedEvent) {
        SetEvent(theStateChangedEvent);
    }
}


/**
* UPSTurnOff
*
* Description:
*   Attempts to turn off the outlets on the UPS
*   after the specified delay.  This method querries the 
*   UPS for the allowed shutdown delays and sets the
*   delay to one of the following:
*     1. aTurnOffDelay if it exactly matches one of the allowed values
*     2. the next highest value after aTurnOffDelay, if one exists
*     3. the highest allowed value, if aTurnOffDelay is larger than all of
*        the allowed values.
*   If no allowed values are returned, the Shutdown Delay will not be set.
*   Next the UPS is instructed to sleep until power is restored.
*
* Parameters:
*   aTurnOffDelay: the minimum amount of time to wait before
*                  turning off the outlets on the UPS
*
* Returns:
*   None
*   
*/
void ApcMiniDriver::UPSTurnOff(DWORD aTurnOffDelay)
{
    if (theUpsApp) {
        char allowed_values[512];

        // Retrieve the allowed shutdown delays from the UPS
        theUpsApp->Get(ALLOWED_SHUTDOWN_DELAYS, allowed_values);

				TokenString token_str(allowed_values, SHUTDOWN_DELAY_SEPARATOR);
				PCHAR tok = token_str.GetCurrentToken();

        // Set the shutdown delay if there are allowed values
        if (tok) {
          
          // Initialize counters
          long requested_value = (long) aTurnOffDelay;
          long max = atol(tok);
          long last_closest = 0;
          
       
          // Cycle through the allowed values looking for a suitable value
				  while (tok) {
            long value = atol(tok);

            // Check to see if this value is closest to the requested
            if ( ((value >= requested_value) && (value < last_closest)) 
              || (last_closest < requested_value)) {
              last_closest = value;
            }

            // Check to see if this value is the max value
            if (value > max) {
              max = value;
            }

            // Get the next value
            tok = token_str.GetCurrentToken();
          }

          long shutdown_delay = last_closest;

          if (last_closest < requested_value) {
            // The requested value is larger than all of the values, use the max
            shutdown_delay = max;
          }

          // Set the shutdown delay
          char shutdown_delay_str[4];
          sprintf(shutdown_delay_str, "%3.3u", shutdown_delay);
          theUpsApp->Set(SHUTDOWN_DELAY, shutdown_delay_str);
        }

        // Signal the UPS to sleep
        theUpsApp->UPSTurnOff();
    }
}


/**
* Update
*
* Description:
*   Update is called when theUpsApp has
*   generated an Event for which this object
*   has registered.
*   Events are defined by a set of integer
*   'codes' defined in the file 'codes.h'
*
* Parameters:
*   anEvent: a pointer to an Event object that
*           defines the generated event
*
* Returns:
*   ErrNO_ERROR   
*   
*/
INT ApcMiniDriver::Update(PEvent anEvent)
{
    INT err = ErrNO_ERROR;
	
    if (!anEvent) {
        return err;
    }
	
    switch (anEvent->GetCode()) {
    case UTILITY_LINE_CONDITION:
        {
            err = onUtilityLineCondition(anEvent);
        }
        break;
		
    case BATTERY_REPLACEMENT_CONDITION:
        {
            err = onBatteryReplacementCondition(anEvent);
        }
        break;
        
    case BATTERY_CONDITION:
        {
            err = onBatteryCondition(anEvent);
        }
        break;
		
    case COMMUNICATION_STATE:
        {
            err = onCommunicationState(anEvent);
        }
        break;

	case TIMER_PULSE:
        {
            err = onTimerPulse(anEvent);
        }
        break;

    default:
        {
            err = UpdateObj::Update(anEvent);
        }
        break;
    }
    return err;
}


/**
* onUtilityLineCondition
*
* Description:
*   Determines the current state of the power
*   and reports any changes to the registry and
*   to any threads pending on UPSWaitForStateChange
*
* Parameters:
*   anEvent: pointer to an Event object that
*           relates to a UTILITY_LINE_CONDITION event
*
* Returns:
*   ErrNO_ERROR
*   
*/
INT ApcMiniDriver::onUtilityLineCondition(PEvent anEvent) 
{
    DWORD state = atoi(anEvent->GetValue());
    DWORD old_state = theState;
	
    if (LINE_BAD == state) {
        theState = UPS_ONBATTERY;
    }
    else {
        theState = UPS_ONLINE;
    }
	
    if (old_state != theState) {
        UPSCancelWait(); 
    }
    return ErrNO_ERROR;
}


/**
* onBatteryReplacementCondition
*
* Description:
*   Determines the current replacement state of the
*   battery and reports any changes to the registry
*
* Parameters:
*   anEvent: pointer to an Event object that
*           relates to a BATTERY_REPLACEMENT_CONDITION event
*
* Returns:
*   ErrNO_ERROR
*   
*/
INT ApcMiniDriver::onBatteryReplacementCondition(PEvent anEvent)
{
    DWORD state = atoi(anEvent->GetValue());
    DWORD old_state = theReplaceBatteryState;
	
    if (BATTERY_NEEDS_REPLACING == state) {
        theReplaceBatteryState = UPS_BATTERYSTATUS_REPLACE;
    }
    else {
        theReplaceBatteryState = UPS_BATTERYSTATUS_GOOD;
    }
	
    if (old_state != theReplaceBatteryState) {
        InitUPSStatusBlock();
        SetUPSStatusBatteryStatus(theReplaceBatteryState);
        SaveUPSStatusBlock(FALSE);
    }
    return ErrNO_ERROR;
}


/**
* onBatteryCondition
*
* Description:
*   Determines the current charge-state of the battery
*   and reports any changes to the registry and
*   to any threads pending on UPSWaitForStateChange
*
* Parameters:
*   anEvent: pointer to an Event object that
*           relates to a BATTERY_CONDITION event
*
* Returns:
*   ErrNO_ERROR
*   
*/
INT ApcMiniDriver::onBatteryCondition(PEvent anEvent)
{
    DWORD old_state = theState;
    DWORD state = atoi(anEvent->GetValue());

    //
    // get the current line condition
    // we only goto low battery if we
    // are also on battery
    //
    char value[256];
    theUpsApp->Get(UTILITY_LINE_CONDITION, value);
    DWORD line_state = atoi(value);
	
    if ((BATTERY_BAD == state) || (LOW_BATTERY == state)) {

        if (LINE_BAD == line_state) {
            theState = UPS_LOWBATTERY;
        }
        else {
            theState = UPS_ONLINE;
        }
    }
    else {
		
        if (LINE_BAD == line_state) {
            theState = UPS_ONBATTERY;
        }
        else {
            theState = UPS_ONLINE;
        }
    }

    if (old_state != theState) {
        UPSCancelWait();
    }
    return ErrNO_ERROR;
}


/**
* onCommunicationState
*
* Description:
*   Determines the communication state to the UPS
*   If theState goes to UPS_NOCOMM we report the change
*   to threads pending on UPSWaitForStateChange
*   If the state is leaving UPS_NOCOMM, we 
*   reinitialize the registry with advanced data
*   and then 'fake' power and battery condition
*   events
*
* Parameters:
*   anEvent: pointer to an Event object that
*           relates to a COMMUNICATION_STATE event
*
* Returns:
*   ErrNO_ERROR
*   
*/
INT ApcMiniDriver::onCommunicationState(PEvent anEvent)
{
    DWORD state = atoi(anEvent->GetValue());
	
    if ((COMMUNICATION_LOST == state) || 
        (COMMUNICATION_LOST_ON_BATTERY == state)) {

        if (UPS_NOCOMM != theState) {
            theState = UPS_NOCOMM;
            UPSCancelWait();
        }
    }
    else {
		
        if (UPS_NOCOMM == theState) {
            //
            // need to re-initialize the UPS data, since
            // when you lose comm, the user might plug in
            // a new UPS system
            //
            initalizeAdvancedUpsData();

            // Set the low battery warning threshold
            setLowBatteryDuration();

            //
            // here we just ask the service what it thinks
            // the current line/battery conditions are, and
            // 'fake' an event to ourselves.  This allows
            // all line/battery state changes to be handled
            // consistently in the same methods
            //
            char value[256];
            theUpsApp->Get(UTILITY_LINE_CONDITION, value);
            Event ulc_evt(UTILITY_LINE_CONDITION, value);
            onUtilityLineCondition(&ulc_evt);
            
            theUpsApp->Get(BATTERY_CONDITION, value);
            Event batt_evt(BATTERY_CONDITION, value);
            onBatteryCondition(&batt_evt);
        }
    }
    return ErrNO_ERROR;
}


/**
* onTimerPulse
*
* Description:
*   Retrieves the on-battery runtime and battery
*   capacity from the UPS and updates the registry
*   with the values if they differ from the last
*   time this method was called
*
* Parameters:
*   anEvent: pointer to an Event object that
*           relates to a TIMER_PULSE event
*
* Returns:
*   ErrNO_ERROR
*   
*/
INT ApcMiniDriver::onTimerPulse(PEvent anEvent)
{
    DWORD old_run_time = theOnBatteryRuntime;
    DWORD old_batt_cap = theBatteryCapacity;

    //
    // get the current on-battery runtime
    //
    CHAR data[100];
    if (theUpsApp->Get(RUN_TIME_REMAINING,data) == ErrNO_ERROR) {
      //
      // we get the RUN_TIME_REMAINING back in seconds
      // the UPS applet expects the value to be in 
      // minutes - 
      theOnBatteryRuntime = atol(data) / 60;
    }

    //
    // get the current battery capacity
    //
    if (theUpsApp->Get(BATTERY_CAPACITY,data) == ErrNO_ERROR) {
      // we get the battery capacity back as a percentage
      // the UPS applet expects only a whole number.
      theBatteryCapacity = (long) atof(data);
    }


    if ((old_run_time != theOnBatteryRuntime) || (old_batt_cap != theBatteryCapacity)){
      // One or more values changed, update the registry
      InitUPSStatusBlock();

      if (old_run_time != theOnBatteryRuntime) {
        // Update run time remaining
        SetUPSStatusRuntime(theOnBatteryRuntime);
      }

      if (old_batt_cap != theBatteryCapacity) {
        SetUPSStatusBatteryCapacity(theBatteryCapacity);
      }

      SaveUPSStatusBlock(FALSE);
    }
    
    //
    // must create another timer to update the
    // value again
    //
    theRunTimeTimer = 
        _theTimerManager->SetTheTimer((ULONG)5, 
        anEvent, 
        this);

    return ErrNO_ERROR;
}


/**
* initalizeAdvancedUpsData
*
* Description:
*   Retrieves the advanced data from theUpsApp
*   and forces an update to the registry with
*   the fresh data
*
* Parameters:
*   None
*
* Returns:
*   ErrNO_ERROR
*   
*/
INT ApcMiniDriver::initalizeAdvancedUpsData()
{
    // Initialize all static registry data
    InitUPSStatusBlock();
    CHAR data[100];
    TCHAR w_data[200];


    theUpsApp->Get(CURRENT_FIRMWARE_REV,data);
#ifdef UNICODE
    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, data, -1,
        w_data, (sizeof(w_data)/sizeof(TCHAR)));
#else
    strcpy(w_data, data);
#endif
    SetUPSStatusFirmRev(w_data);
    

    theUpsApp->Get(UPS_SERIAL_NUMBER,data);
#ifdef UNICODE
    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, data, -1,
        w_data, (sizeof(w_data)/sizeof(TCHAR)));
#else
    strcpy(w_data, data);
#endif
    SetUPSStatusSerialNum(w_data);

    // Default utility power and battery status to GOOD
    SetUPSStatusBatteryStatus(UPS_BATTERYSTATUS_GOOD);
    
    SetUPSStatusBatteryCapacity(0);

    SaveUPSStatusBlock(TRUE);
    
    //
    // dummy up a BATTERY_REPLACEMENT_CONDITION event,
    // just to make sure we initialize the registry with
    // valid data, since this is an event we will not
    // be notified unless the state changes
    //
    theUpsApp->Get(BATTERY_REPLACEMENT_CONDITION, data);
    Event replace_batt(BATTERY_REPLACEMENT_CONDITION, data);
    onBatteryReplacementCondition(&replace_batt);

    return ErrNO_ERROR;
}


/**
* initalizeUpsApplication
*
* Description:
*   inits theUpsApp member with a new NTServerApplication
*   object.  
*   Registers for the events that can be received
*   in the Update method
*   Initalizes the advanced UPS data in the registry,
*   and starts the repeating event that triggers updates
*   to get on-battery runtime data
*
* Parameters:
*   None
*
* Returns:
*   ErrNO_ERROR: init succeeded
*   ErrMEMORY: theUpsApp could not be created
*   
*/
INT ApcMiniDriver::initalizeUpsApplication()
{
    INT err = ErrNO_ERROR;

    //
    // assume that the UPS is not on battery
    // this matches the assumption made by
    // the NTServerApplication class
    //
    theState = UPS_ONLINE;
    theUpsApp = new NTServerApplication();
    
    if (!theUpsApp) {
        err = ErrMEMORY;
    }
    else {
        theUpsApp->RegisterEvent(UTILITY_LINE_CONDITION, this);
        theUpsApp->RegisterEvent(BATTERY_CONDITION, this);
        theUpsApp->RegisterEvent(BATTERY_REPLACEMENT_CONDITION, this);
        theUpsApp->RegisterEvent(COMMUNICATION_STATE, this);	
        
        err = theUpsApp->Start();
    }
    
    if (ErrNO_ERROR == err) {
        initalizeAdvancedUpsData();
        
        // Start the polling of UPS run time
        if (!theRunTimeTimer) {
            Event retry_event(TIMER_PULSE, TIMER_PULSE);
            onTimerPulse(&retry_event);
        }
    }
    return err;
}


/**
* cleanupUpsApplication
*
* Description:
*   cleans up and destructs theUpsApp object.  Sets
*   member variables to the default values
*
*
* Parameters:
*   None
*
* Returns:
*   None
*   
*/
void ApcMiniDriver::cleanupUpsApplication()
{
    theState = UPS_ONLINE;

    if (theUpsApp) {
        theUpsApp->Quit();
        delete theUpsApp;
        theUpsApp = NULL;
    }	
    theRunTimeTimer = 0;
    theOnBatteryRuntime = -1;
}

/**
* setLowBatteryDuration
*
* Description:
*   Sets the low battery duration to a value compatable with the 
*   UPSTurnOffWait registry key. This method querries the 
*   UPS for the allowed low battery durations and sets the
*   duration to one of the following:
*     1. The value of UPSTurnOffWait if it exactly matches one of
*        the allowed values
*     2. the next highest value after UPSTurnOffWait, if one exists
*     3. the highest allowed value, if UPSTurnOffWait is larger than
*        all of the allowed values.
*   If the UPSTurnOffWait is not set or no allowed values are returned,
*   the low battery duration will not be set.
*
* Parameters:
*   None
*
* Returns:
*   None
*   
*/
void ApcMiniDriver::setLowBatteryDuration() {
  DWORD turn_off_wait;

  InitUPSConfigBlock();

  if ((GetUPSConfigTurnOffWait(&turn_off_wait) == ERROR_SUCCESS) && (theUpsApp)) {
    char allowed_values[512];
    
    // Retrieve the allowed low battery durations from the UPS
    theUpsApp->Get(ALLOWED_LOW_BATTERY_DURATIONS, allowed_values);
    
		TokenString token_str(allowed_values, LOW_BATT_DURATION_SEPARATOR);
    PCHAR tok = token_str.GetCurrentToken();
    
    // Set the low battery duration if there are allowed values
    if (tok) {
      
      // Initialize counters
      long max = atol(tok);
      long last_closest = 0;
      long requested_value = 0;
      if (turn_off_wait > 0) {
        // Convert the value from seconds to minutes (rounded up)
        requested_value = turn_off_wait / SECONDS_TO_MINUTES;
        if ((turn_off_wait % SECONDS_TO_MINUTES) > 0) {
          ++requested_value;
        }
      }
      
      
      // Cycle through the allowed values looking for a suitable value
      while (tok) {
        long value = atol(tok);
        
        // Check to see if this value is closest to the requested
        if ( ((value >= requested_value) && (value < last_closest)) 
          || (last_closest < requested_value)) {
          last_closest = value;
        }
        
        // Check to see if this value is the max value
        if (value > max) {
          max = value;
        }
        
        // Get the next value
        tok = token_str.GetCurrentToken();
      }
      
      long low_batt_duration = last_closest;
      
      if (last_closest < requested_value) {
        // The requested value is larger than all of the values, use the max
        low_batt_duration = max;
      }
      
      // Set the shutdown delay
      char low_batt_duration_str[4];
      sprintf(low_batt_duration_str, "%2.2u", low_batt_duration);
      theUpsApp->Set(LOW_BATTERY_DURATION, low_batt_duration_str);
    }
  }
}