/*
 * OutputGPIOInterface.h
 *
 *  Created on: May 31, 2018
 *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert
 */

#include "OutputGPIOInterface.h"

namespace flippR_driver
{
namespace output
{
using namespace output::items;
using namespace nlohmann;

OutputGPIOInterface::OutputGPIOInterface(std::map<std::string, uint8_t> pins_driver_board, std::map<std::string, uint8_t> pins_sound, std::map<std::string, uint8_t> pins_display)
  : pins_driver_board(pins_driver_board), pins_sound(pins_sound), pins_display(pins_display)
{
  initialize_i2c_addresses();

  initialize_pins();
}

void OutputGPIOInterface::initialize_pins()
{
  // Since this are all outputs we just initialize everything as output conveniently
  initialize_all_pins(pins_driver_board["pin_base"]);
  initialize_all_pins(pins_sound["pin_base"]);
  initialize_all_pins(pins_display["pin_base"]);
}

void OutputGPIOInterface::initialize_all_pins(uint8_t pin_base)
{
  for(int i = 0; i < 16; i++)
  {
    GPIOInterface::initialize_output_pin(pin_base + i);
  }
}

void OutputGPIOInterface::initialize_i2c_addresses()
{
  mcp23017Setup(pins_driver_board["pin_base"], pins_driver_board["i2c_address"]);
  mcp23017Setup(pins_sound["pin_base"], pins_sound["i2c_address"]);
  mcp23017Setup(pins_display["pin_base"], pins_display["i2c_address"]);
}

void OutputGPIOInterface::activate(output::items::ISoundItem *sound)
{
  std::lock_guard<std::mutex> guard(output_item_mutex);

  write_sound_address(sound->get_address());

  fire_sound(1);
}

void OutputGPIOInterface::activate(output::items::IDriverBoardItem *driver_board_item)
{
  std::lock_guard<std::mutex> guard(output_item_mutex);

  write_driver_board_address(driver_board_item->get_address());

  write_data(1);
}

void OutputGPIOInterface::deactivate(output::items::IDriverBoardItem *driver_board_item)
{
  std::lock_guard<std::mutex> guard(output_item_mutex);

  write_driver_board_address(driver_board_item->get_address());

  write_data(0);
}

void OutputGPIOInterface::deactivate(output::items::ISoundItem *sound)
{
  std::lock_guard<std::mutex> guard(output_item_mutex);

  write_sound_address(sound->get_address());

  fire_sound(0);
}

void OutputGPIOInterface::write_driver_board_address(uint8_t address)
{
  int latch = address / 8;
  int pin = address % 8;

  select_mux(latch);

  select_latch(latch);

  select_pin(pin);
}

void OutputGPIOInterface::select_mux(uint8_t latch)
{
  bool mux1 = latch / 8;

  write_pin(pins_driver_board["mux1"], mux1);
  write_pin(pins_driver_board["mux2"], !mux1);
}

void OutputGPIOInterface::select_latch(uint8_t latch)
{
  // todo not nice
  if(latch > 8)
    latch -= 8;

  write_pin(pins_driver_board["latch-select-A"], latch & 0b001);
  write_pin(pins_driver_board["latch-select-B"], latch & 0b010);
  write_pin(pins_driver_board["latch-select-C"], latch & 0b100);

}

void OutputGPIOInterface::write_data(bool data)
{
  write_pin(pins_driver_board["data"], data);
}

void OutputGPIOInterface::select_pin(uint8_t pin)
{
  write_pin(pins_driver_board["pin-select-A"], pin & 0b001);
  write_pin(pins_driver_board["pin-select-B"], pin & 0b010);
  write_pin(pins_driver_board["pin-select-C"], pin & 0b100);
}

void OutputGPIOInterface::write_sound_address(uint8_t address)
{
  write_pin(pins_sound["A"], address & 0b0000001);
  write_pin(pins_sound["B"], address & 0b0000010);
  write_pin(pins_sound["C"], address & 0b0000100);
  write_pin(pins_sound["D"], address & 0b0001000);
  write_pin(pins_sound["E"], address & 0b0010000);
  write_pin(pins_sound["F"], address & 0b0100000);
  write_pin(pins_sound["G"], address & 0b1000000);
}

void OutputGPIOInterface::fire_sound(bool fire)
{
  GPIOInterface::write_pin(pins_sound["fire"], fire);
}

void OutputGPIOInterface::write_display(std::shared_ptr<output::items::IDisplay> display)
{
  return;
}

}
}