#include <libcec/cec.h>
 #include <iostream>
 #include <thread>
 #include <stdio.h>
 #include <unistd.h>
 #include <assert.h>
 
 /*
  * Constants
  */
 const unsigned int receiver_steps = 36;
 const unsigned int default_volume = 20;
 const useconds_t post_send_delay = 200000; 
 const double step_size = ((double) (CEC::CEC_AUDIO_VOLUME_MAX - CEC::CEC_AUDIO_VOLUME_MIN)) / ((double) receiver_steps);
 
 /*
  * Global state
  */
 double current_volume = 0;
 bool current_mute = false;
 CEC::ICECAdapter *adapter = 0;
 
 /*
  * Log object
  */
 class logger {
 public:
     ~logger() { std::cerr << std::endl; }
     template <class T>
     logger &operator<<(T x) {
         std::cerr << x;
         return(*this);
     }
 };
 
 #define logstream(x...) { logger logstreaminstance; logstreaminstance x; }
 
 /*
  * CEC Helpers
  */
 bool cec_execute_command(CEC::ICECAdapter *adapter, char *command) {
     auto command_data = adapter->CommandFromString(command);
     auto tx = adapter->Transmit(command_data);
     if (!tx) {
         std::cerr << "Failed to execute command: " << command << std::endl;
         return(false);
     }
 
     return(true);
 }
 
 bool cec_enable_audio(CEC::ICECAdapter *adapter) {
     return(cec_execute_command(adapter, (char *) "50:72:01"));
 }
 
 bool cec_set_volume(CEC::ICECAdapter *adapter, int volume, bool muted = false) {
     char command[64];
     if (muted) {
         volume |= CEC::CEC_AUDIO_MUTE_STATUS_MASK;
     }
 
     snprintf(command, sizeof(command), "50:7A:%02x", volume);
 
     return(cec_execute_command(adapter, command));
 }
 
 void cec_log_message(void *cb_data, const CEC::cec_log_message *message) {
     // std::cerr << message->message << std::endl;
 }
 
 /*
  * IR Helpers
  */
 void ir_increase_volume() {
     logstream(<< "Increasing volume (from " << current_volume << ")");
 
     system("ir-ctl -d /dev/lirc0 --send ~/cec-volume/mcm-vol-up.ir");
     usleep(post_send_delay);
     return;
 }
 
 void ir_decrease_volume() {
     logstream(<< "Decreasing volume (from " << current_volume << ")");
 
     system("ir-ctl -d /dev/lirc0 --send ~/cec-volume/mcm-vol-down.ir");
     usleep(post_send_delay);
     return;
 }
 
 void ir_toggle_mute() {
     logstream(<< "Toggling mute (from " << current_mute << ")");
 
     system("ir-ctl -d /dev/lirc0 --send ~/cec-volume/mcm-vol-mute.ir");
     usleep(post_send_delay);
     return;
 }
 
 void ir_set_volume(unsigned int value) {
     bool set_mute = current_mute;
 
     logstream(<< "Setting volume to " << value << " with mute = " << set_mute);
 
     if (current_mute) {
         ir_toggle_mute();
         current_mute = !current_mute;
     }
 
     current_volume = CEC::CEC_AUDIO_VOLUME_MAX;
 
     for (unsigned int i = 0; i < receiver_steps; i++) {
         ir_decrease_volume();
         current_volume -= step_size;
     }
 
     assert(current_volume < (CEC::CEC_AUDIO_VOLUME_MIN + step_size + 0.1));
 
     auto steps_value = value / step_size;
     for (unsigned int i = 0; i < steps_value; i++) {
         ir_increase_volume();
         current_volume += step_size;
     }
 
     if (set_mute) {
         ir_toggle_mute();
         current_mute = !current_mute;
     }
 
     logstream(<< "Done setting volume to " << value << "(current_volume =" << current_volume << ")");
 }
 
 /*
  * CEC Callback for a command from the bus to our process
  */
 void cec_handle_command(void *cb_data, const CEC::cec_command *command) {
     if (command->opcode == CEC::CEC_OPCODE_GIVE_AUDIO_STATUS) {
         ((CEC::cec_command *) command)->Clear();
         logstream(<< "Got command CEC_OPCODE_GIVE_AUDIO_STATUS");
         cec_set_volume(adapter, (int) current_volume, current_mute);
     }
 }
 
 /*
  * CEC Callback for handling a key
  */
 std::thread *change_thread = 0;
 void cec_handle_key_thread(CEC::cec_user_control_code keycode) {
     switch (keycode) {
         case CEC::CEC_USER_CONTROL_CODE_VOLUME_DOWN:
             if (current_mute) {
                 ir_toggle_mute();
                 current_mute = !current_mute;
             }
             ir_decrease_volume();
             current_volume -= step_size;
             break;
         case CEC::CEC_USER_CONTROL_CODE_VOLUME_UP:
             if (current_mute) {
                 ir_toggle_mute();
                 current_mute = !current_mute;
             }
             ir_increase_volume();
             current_volume += step_size;
             break;
         case CEC::CEC_USER_CONTROL_CODE_MUTE:
             ir_toggle_mute();
             current_mute = !current_mute;
             break;
         default:
             /* Ignored */
             break;
     }
 
     if (current_volume < CEC::CEC_AUDIO_VOLUME_MIN) {
         current_volume = CEC::CEC_AUDIO_VOLUME_MIN;
     }
 
     if (current_volume > CEC::CEC_AUDIO_VOLUME_MAX) {
         current_volume = CEC::CEC_AUDIO_VOLUME_MAX;
     }
 
     if (adapter) {
         auto tx = cec_set_volume(adapter, (int) current_volume, current_mute);
         if (!tx) {
             std::cerr << "Failed to set volume" << std::endl;
         }
     }
 
     /* Really should be a mutex around this */
     change_thread = 0;
 }
 
 void cec_handle_key(void *cb_data, const CEC::cec_keypress *key_info) {
     /*
      * Key down events are sent with Duration=0, ignore them
      */
     if (key_info->duration == 0) {
         return;
     }
 
     /*
      * If an event is already being processed, ignore this one
      */
     if (change_thread) {
         return;
     }
 
     logstream(<< "Key " << key_info->keycode << "; Duration=" << key_info->duration);
     change_thread = new std::thread(cec_handle_key_thread, key_info->keycode);
 }
 
 int main(int argc, char *argv[]) {
     CEC::libcec_configuration configuration;
     CEC::ICECCallbacks callbacks;
 
     configuration.Clear();
     configuration.deviceTypes.Add(CEC::CEC_DEVICE_TYPE_AUDIO_SYSTEM);
     configuration.clientVersion = CEC::LIBCEC_VERSION_CURRENT;
     configuration.bActivateSource = 0;
     sprintf(configuration.strDeviceName, "SchiitModi3");
 
     adapter = CECInitialise(&configuration);
 
     /*
      * What if I wasn't using the RPI port ?
      */
     adapter->InitVideoStandalone();
 
     callbacks.Clear();
     callbacks.logMessage = &cec_log_message;
     callbacks.keyPress = &cec_handle_key;
     callbacks.commandReceived = &cec_handle_command;
 
 #if CEC_LIB_VERSION_MAJOR >= 5
     auto set_callbacks_ret = adapter->SetCallbacks(&callbacks);
 #else
     auto set_callbacks_ret = adapter->EnableCallbacks(0, &callbacks);
 #endif
 
     if (!set_callbacks_ret) {
         std::cerr << "Failed to set callbacks" << std::endl;
         return(4);
     }
 
     auto open_ret = adapter->Open("RPI");
     if (!open_ret) {
         std::cerr << "Failed to open port" << std::endl;
         return(1);
     }
 
     auto audio_ret = cec_enable_audio(adapter);
     if (!audio_ret) {
         std::cerr << "Failed to enable audio" << std::endl;
         return(2);
     }
 
     ir_set_volume(default_volume);
 
     /*
      * Another thread handles sending callbacks, so we just need to wait forever.
      */
     while (true) {
         sleep(300);
     }
 }