#include <sta/devices/stm32/gpio_pin.hpp>
#ifdef STA_STM32_GPIO_ENABLED

#include <sta/debug/assert.hpp>
#include <sta/lang.hpp>


namespace sta
{
    STM32GpioPin::STM32GpioPin(GPIO_TypeDef * port, uint16_t pin)
        : port_{port}, pin_{pin}
    {
        STA_ASSERT(port != nullptr);
    }

    void STM32GpioPin::setState(GpioPinState state)
    {
        HAL_GPIO_WritePin(port_, pin_, (state == GpioPinState::GPIO_LOW) ? GPIO_PIN_RESET : GPIO_PIN_SET);
    }

    GpioPinState STM32GpioPin::getState()
    {
        return HAL_GPIO_ReadPin(port_, pin_) == GPIO_PIN_RESET ? GpioPinState::GPIO_LOW : GpioPinState::GPIO_HIGH; 
    }

    GPIO_TypeDef * STM32GpioPin::getPort() const
    {
        return port_;
    }

    uint16_t STM32GpioPin::getPin() const
    {
        return pin_;
    }

    uint8_t STM32GpioPin::getPortIndex() const
    {
        return GPIO_GET_INDEX(port_);
    }


    bool isInterruptEdge(const STM32GpioPin & gpioPin, InterruptEdge edge)
    {
        uint32_t pin = gpioPin.getPin();

        for (uint32_t i = 0; i < 8 * sizeof(pin); ++i)    //why 8?
        {
            uint32_t ioPos = 1U << i;
            if (pin & ioPos)
            {
                // Check input mode
                uint32_t mode = (gpioPin.getPort()->MODER >> (2U * i)) & 0x3UL;				//GPIO_MODE to 0x3UL
                //uint32_t mode =  LL_GPIO_GetPinMode (gpioPin.getPort(), pin);
                if (mode != 0x0UL)		//MODE_INPUT to 0x0UL
                {
                    return false;
                }

                // Is EXTI configured?
                if (EXTI->IMR1 & ioPos)		//changed IMR to IMR1
                {
                    bool rising  = (EXTI->RTSR1 & ioPos); // changed RTSR to RTSR1
                    bool falling = (EXTI->FTSR1 & ioPos);

                    switch (edge)
                    {
                    case InterruptEdge::RISING:
                        return rising;

                    case InterruptEdge::FALLING:
                        return falling;

                    case InterruptEdge::BOTH:
                        return rising && falling;

                    default:
                        STA_ASSERT(false);
                        STA_UNREACHABLE();
                    }
                }
            }
        }

        return false;
    }
} // namespace sta


#endif // STA_STM32_GPIO_ENABLED