
#if defined(unix) || defined(__unix__) || defined(__unix)

#include <iostream>

#include <unistd.h>
#include <pigpiod_if2.h>

#include <libpiglinux.h>
#include <pigi2c.h>

using namespace pigpio;


pigLinux::pigLinux() noexcept
{
    //::gpioInitialise();
    /// Connect to Pi.
    constexpr char* optHost = nullptr;
    constexpr char* optPort = nullptr;
    _Pi = ::pigpio_start( optHost, optPort );
    if( _Pi < 0 )
        std::cout <<  "-- pigLinux(): FAIL" << std::endl;
}


pigLinux::~pigLinux()
{
    //::gpioTerminate();
    ::pigpio_stop( _Pi );
}

int pigLinux::init( const std::string& host, const std::string& port )
{
    //::gpioInitialise();
    /// Connect to Pi.
    _Pi = ::pigpio_start( host.c_str(), port.c_str() );
    if( _Pi < 0 )
        std::cout <<  "-- pigLinux(): FAIL" << std::endl;
    return _Pi;
}


///
///  pin config
///

int pigLinux::set_io_mode( bcm_t bcm, io_t mode )
{
    int result = ::set_mode( _Pi, (unsigned) bcm, (unsigned) mode );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::get_io_mode( bcm_t bcm )
{
    int result = ::get_mode( _Pi, (unsigned) bcm );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::set_pud_mode( bcm_t bcm, pud_t pud )
{
    int result = ::set_pull_up_down( _Pi, (unsigned) bcm, (unsigned) pud );
    if( result < 0 )
        return show_error( result );
    return result;
}


int pigLinux::set_glitch_filter( bcm_t bcm , uint32_t glitch )
{
    int result = ::set_glitch_filter( _Pi, (unsigned) bcm, glitch );
    if( result < 0 )
        return show_error( result );
    return result;
}

//Sets a noise filter on a GPIO.
int pigLinux::set_noise_filter( bcm_t bcm , unsigned steady, unsigned active )
{

    int result = ::set_noise_filter( _Pi, (unsigned) bcm, steady, active );
    if( result < 0 )
        return show_error( result );
    return result;


}


///
/// pin operations
///

int pigLinux::get_level( bcm_t bcm )
{
   return ::gpio_read( _Pi, (unsigned) bcm );
}


int pigLinux::set_level( bcm_t bcm , level_t level )
{
   int result = ::gpio_write( _Pi, (unsigned) bcm, level ); ;
   if( result < 0 )
       return show_error( result );
   return result;

}

//This function sends a trigger pulse to a GPIO. The GPIO is set to level for pulseLen microseconds and then reset to not level.
int pigLinux::trigger_level( bcm_t bcm ,  level_t level, uint32_t pulseLen )
{
    int result = ::gpio_trigger( _Pi, (unsigned) bcm, pulseLen, level ); ;
    if( result < 0 )
        return show_error( result );
    return result;
}


int pigLinux::wait_for_edge( bcm_t bcm , edge_t edge, double tout )
{
    int result = ::wait_for_edge( _Pi, (unsigned) bcm, (unsigned) edge, tout );
    if( result < 0 )
        return show_error( result );
    return result;

}


int pigLinux::set_callback( bcm_t bcm, pigCall* fn, edge_t edge )
{
    int result = ::callback_ex( _Pi, (unsigned) bcm, (unsigned) edge, trigger, fn );
    if( result < 0 )
       return show_error( result );

    return result;

}


int pigLinux::cancel_callback( int cbId )
{
  int result = ::callback_cancel( cbId );
  if( result < 0 )
      return show_error( result );
  return result;
}


///
/// ic2
///

int pigLinux::i2c_open( pigI2C& i2c )
{
    int result = i2c.handle = ::i2c_open( _Pi, i2c.bus, i2c.addr, 0 );
    if( result < 0 )
        return show_error( result );
    return result;
}


int pigLinux::i2c_close( pigI2C& i2c )
{
    int result = ::i2c_close( _Pi, i2c.handle );
    if( result < 0 )
        return show_error( result );
    return result;
}

/*
int pigLinux::i2c_write_quick( pigI2C& i2c, unsigned bit )
{
    int result = ::i2c_write_quick( _Pi, i2c.handle, bit );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::i2c_write_byte( pigI2C& i2c, unsigned bVal )
{
    int result = ::i2c_write_byte( _Pi, i2c.handle, bVal );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::i2c_write_byte_data( pigI2C& i2c, unsigned reg, unsigned val )
{
    int result = ::i2c_write_byte_data( _Pi, i2c.handle, reg, val );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::i2c_write_word_data( pigI2C& i2c, unsigned reg, unsigned val )
{
    int result = ::i2c_write_word_data( _Pi, i2c.handle, reg, val );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::i2c_write_block_data( pigI2C& i2c, unsigned reg, char* buf, unsigned count  )
{
    int result = ::i2c_write_block_data( _Pi, i2c.handle, reg, buf, count );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::i2c_write_i2c_block_data( pigI2C& i2c, unsigned reg, char* buf, unsigned count )
{
    int result = ::i2c_write_i2c_block_data( _Pi, i2c.handle, reg, buf, count );
    if( result < 0 )
        return show_error( result );
    return result;
}
*/

int pigLinux::i2c_write_device( pigI2C& i2c, char* buf, unsigned count )
{
    int result = ::i2c_write_device( _Pi, i2c.handle, buf, count );
    if( result < 0 )
        return show_error( result );
    return result;
}

/*
int pigLinux::i2c_read_byte( pigI2C& i2c )
{
    int result = ::i2c_read_byte( _Pi, i2c.handle );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::i2c_read_byte_data( pigI2C& i2c, unsigned reg )
{
    int result = ::i2c_read_byte_data( _Pi, i2c.handle, reg );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::i2c_read_word_data( pigI2C& i2c, unsigned reg )
{
    int result = ::i2c_read_word_data( _Pi, i2c.handle, reg );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::i2c_read_block_data( pigI2C& i2c, unsigned reg, char* buf )
{
    int result = ::i2c_read_block_data( _Pi, i2c.handle, reg, buf );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::i2c_read_i2c_block_data( pigI2C& i2c, unsigned reg, char* buf, unsigned count )
{
    int result = ::i2c_read_i2c_block_data( _Pi, i2c.handle, reg, buf, count );
    if( result < 0 )
        return show_error( result );
    return result;
}


int pigLinux::i2c_read_device( pigI2C& i2c, char* buf, unsigned count )
{
    int result = ::i2c_read_device( _Pi, i2c.handle, buf, count );
    if( result < 0 )
        return show_error( result );
    return result;
}

int pigLinux::i2c_process_call( pigI2C& i2c, unsigned reg, unsigned wVal )
{
    int result = ::i2c_process_call( _Pi, i2c.handle, reg, wVal );
    if( result < 0 )
        return show_error( result );
    return result;
}


int pigLinux::i2c_block_process_call( pigI2C& i2c,unsigned reg, char* buf, unsigned count )
{
    int result = ::i2c_block_process_call( _Pi, i2c.handle, reg, buf, count );
    if( result < 0 )
        return show_error( result );
    return result;
}


int pigLinux::i2c_zip( pigI2C& i2c, char *inBuf, unsigned inLen, char *outBuf, unsigned outLen )
{
    int result = ::i2c_zip( _Pi, i2c.handle, inBuf, inLen, outBuf, outLen );
    if( result < 0 )
        return show_error( result );
    return result;
}
*/


///
/// advanced
///

//Starts hardware PWM on a GPIO at the specified frequency and dutycycle. Frequencies above 30MHz are unlikely to work.

int pigLinux::hardware_PWM( bcm_t bcm , unsigned PWMfreq, uint32_t PWMduty )
{
    //int hardware_PWM(int pi, unsigned gpio, unsigned PWMfreq, uint32_t PWMduty)
    int result = ::hardware_PWM( _Pi, (unsigned) bcm, PWMfreq, PWMduty );
    if( result < 0 )
        return show_error( result );
    return result;
}

//Starts a hardware clock on a GPIO at the specified frequency. Frequencies above 30MHz are unlikely to work.

int pigLinux::hardware_clock( bcm_t bcm , unsigned clkfreq )
{
    //int hardware_clock(int pi, unsigned gpio, unsigned clkfreq)
    int result = ::hardware_clock( _Pi, (unsigned) bcm,  clkfreq );
    if( result < 0 )
        return show_error( result );
    return result;

}

uint32_t pigLinux::get_current_tick()
{
    //int hardware_clock(int pi, unsigned gpio, unsigned clkfreq)
    return ::get_current_tick( _Pi );
}


///
/// convenience
///


int pigLinux::show_error( int error )
{
    std::cout << "Error: " << ::pigpio_error( error ) << std::endl;
    return error;
}



/// ---

//Get the Pi's hardware revision number.

int pigLinux::get_hardware_revision()
{
    int result = ::get_hardware_revision( _Pi );
    if( result < 0 )
        return show_error( result );
    return result;

}

//Returns the pigpio version.

int pigLinux::get_pigpio_version()
{
    int result = ::get_pigpio_version( _Pi );
    if( result < 0 )
        return show_error( result );
    return result;

}

//Return the pigpiod_if2 version.

unsigned pigLinux::pigpiod_if_version()
{
    //unsigned pigpiod_if_version(void)
    int result = ::pigpiod_if_version();
    if( result < 0 )
        return show_error( result );
    return result;
}

#endif

