//======================================================================
// RigMode.h
//======================================================================

#ifndef __RigMode_h__
#define __RigMode_h__

// Exceptions not active (for Arduino, I assume?).
//enum IModeExceptions {
//  MODE_ALREADY_ACTIVE = -1,
//  MODE_STILL_TRANSMITTING = -2,
//  MODE_ALREADY_TRANSMITTING = -3,
//  MODE_NOT_TRANSMITTING = -4,
//};

//======================================================================
// IMode
//
// Interface to a rig mode (SSB, CW, etc.).
//======================================================================

class IMode {
  public:
  
  IMode(IConfig& c, RigAudio& a): 
  _config(c), _audio(a), _active(false), _transmitting(false) 
  {
  }
  
  virtual ~IMode() {}

  inline IConfig& config() { return _config; }

  inline RigAudio& audio() { return _audio; }

  // Called upon mode entry.  Should assume that the rig's state is 
  // "clean", i.e. that it still needs to enable anything it needs for
  // use in the mode.
  virtual void onEntry() = 0;

  // Called upon mode exit.  Should clean everything up that it used,
  // and not make assumptions about which mode is being entered next.
  virtual void onExit() = 0;

  // Called when transmitting.
  virtual void onTx() = 0;

  // Called when receiving.
  virtual void onRx() = 0;

  inline void enter() {
    if (_active) {
      // Do nothing.  Exceptions not active (for Arduino, I assume?).
      //throw MODE_ALREADY_ACTIVE;
      USBDEBUG("ERROR - tried to enter mode, but it's already active");
    } else {
      _active = true;
      onEntry();
    }
  }

  inline void exit() {
    if (_transmitting) {
      // Do nothing.  Exceptions not active (for Arduino, I assume?).
      //throw MODE_STILL_TRANSMITTING;
      USBDEBUG("ERROR - tried to exit mode, but it's transmitting");
    } else {
      _active = false;
      onExit();
    }
  }

  inline bool isActive() { return _active; }
  inline bool isInactive() { return !_active; }

  inline void tx() {
    if (_transmitting) {
      // Do nothing.  Exceptions not active (for Arduino, I assume?).
      //throw MODE_ALREADY_TRANSMITTING;
      USBDEBUG("ERROR - tried to start transmitting, but mode already is transmitting");
    } else {
      _transmitting = true;
      onTx();
    }
  }

  inline void rx() {
    if (!_transmitting) {
      // Do nothing.  Exceptions not active (for Arduino, I assume?).
      //throw MODE_NOT_TRANSMITTING;
      USBDEBUG("ERROR - tried to start receiving, but mode already is receiving");
    } else {
      _transmitting = false;
      onRx();
    }
  }

  inline bool isTx() const { return _transmitting; }
  inline bool isRx() const { return !_transmitting; }

  private:
  
  IConfig& _config;
  RigAudio& _audio;
  bool _active;
  bool _transmitting;
};

//======================================================================
// SSBMode
//======================================================================

class SSBMode : public IMode 
{
  public:

  SSBMode(IConfig& c, RigAudio& a, bool default_mic=true): 
  IMode(c, a), _use_mic(default_mic) 
  {    
  }
  
  virtual void onEntry() 
  {
    audio().unmuteRx();
    audio().muteAllTx();
    USBDEBUG("SSB mode entered");
  }
  
  virtual void onExit() {    
    audio().muteAllTx();
    audio().muteRx();
    USBDEBUG("SSB mode exited");
  }
  
  virtual void onTx() 
  {
    audio().muteRx();    
    if (_use_mic) {
      audio().unmuteMicIn();
    } else {
      audio().unmuteLineIn();      
    }
    USBDEBUG("SSB mode transmitting");
  }
  
  virtual void onRx() 
  {    
    if (_use_mic) {
      audio().muteMicIn();
    } else {
      audio().muteLineIn();
    }
    audio().unmuteRx();
    USBDEBUG("SSB mode receiving");
  }

  void setMicIn() 
  {
    if (isRx()) {
      // can't switch inputs while already transmitting
      _use_mic = true;
    }
    USBDEBUG("SSB mode - Mic In set");
  }

  void setLineIn() 
  {
    if (isRx()) {
      // can't switch inputs while already transmitting
      _use_mic = false;
    }
    USBDEBUG("SSB mode - Line In set");
  }

  private:

  bool _use_mic;
};

//======================================================================
// DGTMode
//======================================================================

class DGTMode : public IMode 
{
  public:

  DGTMode(IConfig& c, RigAudio& a): 
  IMode(c, a)
  {    
  }
  
  virtual void onEntry() 
  {
    audio().unmuteRx();
    audio().muteAllTx();
    USBDEBUG("DGT mode entered");
  }
  
  virtual void onExit() {    
    audio().muteAllTx();
    audio().muteRx();
    USBDEBUG("DGT mode exited");
  }
  
  virtual void onTx() 
  {
    audio().muteRx();
    audio().unmuteUSBIn();
    USBDEBUG("DGT mode transmitting");
  }
  
  virtual void onRx() 
  {    
    audio().muteUSBIn();
    audio().unmuteRx();
    USBDEBUG("DGT mode receiving");
  }
};


//======================================================================
// CWMode
//======================================================================

class CWMode : public IMode 
{
  public:

  CWMode(IConfig& c, RigAudio& a): 
  IMode(c, a)
  {    
  }
  
  virtual void onEntry() 
  {
    audio().unmuteRx();
    audio().muteAllTx();
    USBDEBUG("CW mode entered");
  }
  
  virtual void onExit() {    
    audio().muteAllTx();
    audio().muteRx();
    USBDEBUG("CW mode exited");
  }
  
  virtual void onTx() 
  {
    // Currently not muting Rx, since the uBITX produces it's own
    // sidetone... but I'm probably going to replace that with a S/W-
    // generated sidetone.
    USBDEBUG("CW mode transmitting");
  }
  
  virtual void onRx() 
  {    
    USBDEBUG("CW mode receiving");
  }
};

//======================================================================
// TTMode
//======================================================================

class TTMode : public IMode 
{
  public:

  TTMode(IConfig& c, RigAudio& a): 
  IMode(c, a)
  {    
  }
  
  virtual void onEntry() 
  {
    audio().unmuteRx();
    audio().muteAllTx();
    USBDEBUG("Test (Two-Tone) mode entered");
  }
  
  virtual void onExit() {    
    audio().muteAllTx();
    audio().muteRx();
    USBDEBUG("Test (Two-Tone) mode exited");
  }
  
  virtual void onTx() 
  {
    audio().muteRx();
    audio().unmuteTTIn();
    USBDEBUG("Test (Two-Tone) mode transmitting");
  }
  
  virtual void onRx() 
  {
    audio().muteTTIn();
    audio().unmuteRx();
    USBDEBUG("Test (Two-Tone) mode receiving");
  }
};

#endif

//======================================================================
// EOF
//======================================================================