#include <sta/devices/arduino/bus/spi.hpp>

#include <sta/lang.hpp>

namespace sta
{
#ifndef STA_PLATFORM_ARDUINO_DEVICE_ESP32
    ArduinoSPI::ArduinoSPI(const SPISettings & settings, Mutex * mutex /* = sta::Mutex::ALWAYS_FREE */)
        : SPI{ settings, mutex },
          spi_{}
    {
        spi_.begin();
    }
#else
    ArduinoSPI::ArduinoSPI(SPIBus bus, const SPISettings & settings, Mutex * mutex /* = sta::Mutex::ALWAYS_FREE */)
        : SPI{ settings, mutex },
          spi_{ bus }
    {
        spi_.begin();
    }
#endif // !STA_PLATFORM_ARDUINO_DEVICE_ESP32

    void ArduinoSPI::transfer(uint8_t value)
    {
        spi_.transfer(value);
    }

    void ArduinoSPI::transfer16(uint16_t value)
    {
        spi_.transfer16(value);
    }

    void ArduinoSPI::transfer(const uint8_t * buffer, size_t size)
    {
        // We have to create a temporary buffer here because the buffer argument in SPIClass::transfer is not const.
        uint8_t temp_buffer[size];
        memcpy(temp_buffer, buffer, size);

        spi_.transfer(temp_buffer, size);
    }

    void ArduinoSPI::transfer(const uint8_t * txBuffer, uint8_t * rxBuffer, size_t size)
    {
        // Copy txBuffer content into rxBuffer, SPIClass::transfer will store received values in rxBuffer.
        memcpy(rxBuffer, txBuffer, size);

        spi_.transfer(rxBuffer, size);
    }

    void ArduinoSPI::receive(uint8_t * buffer, size_t size)
    {
        spi_.transfer(buffer, size);
    }

    void ArduinoSPI::fill(uint8_t value, size_t count) 
    {
        uint8_t temp_buffer[count];
        memset(temp_buffer, value, count);

        spi_.transfer(temp_buffer, count);
    }

    void ArduinoSPI::acquire()
    {
        SPI::acquire();

        const SPISettings & set = settings();

        uint8_t dataMode;
        switch (set.mode)
        {
        case SPIMode::MODE_0:
            dataMode = SPI_MODE0;
            break;
        case SPIMode::MODE_1:
            dataMode = SPI_MODE1;
            break;
        case SPIMode::MODE_2:
            dataMode = SPI_MODE2;
            break;
        case SPIMode::MODE_3:
            dataMode = SPI_MODE3;
            break;        
        default:
            STA_UNREACHABLE();
            break;
        }

        uint8_t bitOrder;
        switch (set.bitOrder)
        {
        case SPIBitOrder::MSB:
            bitOrder = MSBFIRST;
            break;
        case SPIBitOrder::LSB:
            bitOrder = LSBFIRST;
            break;
        default:
            STA_UNREACHABLE();
            break;
        }

        hal::SPISettings halSettings(set.clkSpeed, bitOrder, dataMode);

        spi_.beginTransaction(halSettings);
    }

    void ArduinoSPI::release()
    {
        spi_.endTransaction();

        SPI::release();
    }

    ArduinoSPIDevice::ArduinoSPIDevice(ArduinoSPI * intf, ArduinoGpioPin * csPin)
        : SPIDevice{intf, csPin}
    {
        csPin->setState(GpioPinState::GPIO_HIGH);
    }
} // namespace sta