// IWYU pragma: private

#ifndef __INC_CLOCKLESS_BLOCK_ESP8266_H
#define __INC_CLOCKLESS_BLOCK_ESP8266_H

#include "fl/stl/stdint.h"
#include "fl/stl/static_assert.h"
#include "platforms/esp/32/core/clock_cycles.h"
#include "esp_intr_alloc.h"
#include "eorder.h"
#include "transpose8x1_noinline.h"
#include "fl/stl/compiler_control.h"
#include "fl/chipsets/timing_traits.h"
#include "fl/math/math.h"
#include "fl/stl/noexcept.h"

FL_DISABLE_WARNING_PUSH
FL_DISABLE_WARNING_DEPRECATED_REGISTER

#define FASTLED_HAS_BLOCKLESS 1

#define PORT_MASK (((1<<LANES)-1) & 0x0000FFFFL)
#define USED_LANES (fl::min(LANES,4))
#define REAL_FIRST_PIN 12
#define LAST_PIN (12 + USED_LANES - 1)

// These are completely made up but allow the code to compile.
// It looks like esp32 has a more flexible pin mapping than esp8266.
// so these might actually work.
#define PORTD_FIRST_PIN 12
#define PORTA_FIRST_PIN 14
#define PORTB_FIRST_PIN 16
namespace fl {
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
extern u32 _frame_cnt;
extern u32 _retry_cnt;
#endif

FASTLED_FORCE_INLINE void interrupt_unlock() FL_NOEXCEPT {
	// ets_intr_unlock();
	// TODO: imlement interrupt_unlock?
	// These functions were mined out of the code below and
	// made no-ops here. We probably want to implement them.
}

FASTLED_FORCE_INLINE void interrupt_lock() FL_NOEXCEPT {
	// ets_intr_lock();
	// TODO: imlement interrupt_lock?
}

template <u8 LANES, int FIRST_PIN, typename TIMING, EOrder RGB_ORDER = GRB, int XTRA0 = 0, bool FLIP = false>
class InlineBlockClocklessController : public CPixelLEDController<RGB_ORDER, LANES, PORT_MASK> {
    typedef typename FastPin<FIRST_PIN>::port_ptr_t data_ptr_t;
    typedef typename FastPin<FIRST_PIN>::port_t data_t;

    // Convert nanoseconds to CPU cycles (compile-time)
    // Formula: cycles = (ns * (F_CPU / 1MHz) + 500) / 1000
    // +500 for rounding to nearest cycle
    static constexpr u32 NS_TO_CYCLES(u32 ns) {
        return (ns * (F_CPU / 1000000UL) + 500) / 1000;
    }

    enum : u32 {
        T1 = NS_TO_CYCLES(TIMING::T1),  // Convert nanoseconds → CPU cycles
        T2 = NS_TO_CYCLES(TIMING::T2),
        T3 = NS_TO_CYCLES(TIMING::T3),
        WAIT_TIME = TIMING::RESET  // Already in microseconds (no conversion)
    };

	// Verify that the pin is valid
	FL_STATIC_ASSERT(FastPin<FIRST_PIN>::validpin(), "This pin has been marked as an invalid pin, common reasons includes it being a ground pin, read only, or too noisy (e.g. hooked up to the uart).");

	data_t mPinMask;
    data_ptr_t mPort;
    CMinWait<WAIT_TIME> mWait;

public:
    virtual int size() { return CLEDController::size() * LANES; }

    virtual void showPixels(PixelController<RGB_ORDER, LANES, PORT_MASK> & pixels) FL_NOEXCEPT {
	// mWait.wait();
	/*u32 clocks = */
	int cnt=FASTLED_INTERRUPT_RETRY_COUNT;
	while(!showRGBInternal(pixels) && cnt--) {
	    // ets_intr_unlock();
		interrupt_unlock();
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
	    ++_retry_cnt;
#endif
	    delayMicroseconds(WAIT_TIME * 10);
	    // ets_intr_lock();
		interrupt_lock();
	}
	// #if FASTLED_ALLOW_INTTERUPTS == 0
	// Adjust the timer
	// long microsTaken = CLKS_TO_MICROS(clocks);
	// MS_COUNTER += (1 + (microsTaken / 1000));
	// #endif
	
	// mWait.mark();
    }

    template<int PIN> static void initPin() FL_NOEXCEPT {
	if(PIN >= REAL_FIRST_PIN && PIN <= LAST_PIN) {
	    _ESPPIN<PIN, 1<<(PIN & 0xFF), true>::setOutput();
	    // FastPin<PIN>::setOutput();
	}
    }

    virtual void init() FL_NOEXCEPT {
	// Only supportd on pins 12-15
        // SZG: This probably won't work (check pins definitions in fastpin_esp32)
	initPin<12>();
	initPin<13>();
	initPin<14>();
	initPin<15>();
	mPinMask = FastPin<FIRST_PIN>::mask();
	mPort = FastPin<FIRST_PIN>::port();
	
	// Serial.print("Mask is "); Serial.println(PORT_MASK);
    }

    virtual u16 getMaxRefreshRate() const { return 400; }
    
    typedef union {
	u8 bytes[8];
	u16 shorts[4];
	u32 raw[2];
    } Lines;

#define ESP_ADJUST 0 // (2*(F_CPU/24000000))
#define ESP_ADJUST2 0
    template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER u32 & last_mark, FASTLED_REGISTER Lines & b, PixelController<RGB_ORDER, LANES, PORT_MASK> &pixels) FL_NOEXCEPT { // , FASTLED_REGISTER uint32_t & b2)  {
	Lines b2 = b;
	transpose8x1_noinline(b.bytes,b2.bytes);
	
	FASTLED_REGISTER u8 d = pixels.template getd<PX>(pixels);
	FASTLED_REGISTER u8 scale = pixels.template getscale<PX>(pixels);
	
	for(FASTLED_REGISTER u32 i = 0; i < USED_LANES; ++i) {
	    while((__clock_cycles() - last_mark) < (T1+T2+T3));
	    last_mark = __clock_cycles();
	    *FastPin<FIRST_PIN>::sport() = PORT_MASK << REAL_FIRST_PIN;
	    
	    u32 nword = ((u32)(~b2.bytes[7-i]) & PORT_MASK) << REAL_FIRST_PIN;
	    while((__clock_cycles() - last_mark) < (T1-6));
	    *FastPin<FIRST_PIN>::cport() = nword;
	    
	    while((__clock_cycles() - last_mark) < (T1+T2));
	    *FastPin<FIRST_PIN>::cport() = PORT_MASK << REAL_FIRST_PIN;
	    
	    b.bytes[i] = pixels.template loadAndScale<PX>(pixels,i,d,scale);
	}

	for(FASTLED_REGISTER u32 i = USED_LANES; i < 8; ++i) {
	    while((__clock_cycles() - last_mark) < (T1+T2+T3));
	    last_mark = __clock_cycles();
	    *FastPin<FIRST_PIN>::sport() = PORT_MASK << REAL_FIRST_PIN;
	    
	    u32 nword = ((u32)(~b2.bytes[7-i]) & PORT_MASK) << REAL_FIRST_PIN;
	    while((__clock_cycles() - last_mark) < (T1-6));
	    *FastPin<FIRST_PIN>::cport() = nword;
	    
	    while((__clock_cycles() - last_mark) < (T1+T2));
	    *FastPin<FIRST_PIN>::cport() = PORT_MASK << REAL_FIRST_PIN;
	}
    }

    // This method is made static to force making register Y available to use for data on AVR - if the method is non-static, then
    // gcc will use register Y for the this pointer.
    static u32 showRGBInternal(PixelController<RGB_ORDER, LANES, PORT_MASK> &allpixels) FL_NOEXCEPT {
	
	// Setup the pixel controller and load/scale the first byte
	Lines b0;
	
	for(int i = 0; i < USED_LANES; ++i) {
	    b0.bytes[i] = allpixels.loadAndScale0(i);
	}
	allpixels.preStepFirstByteDithering();
	
	// ets_intr_lock();
	interrupt_lock();
	u32 _start = __clock_cycles();
	u32 last_mark = _start;
	
	while(allpixels.has(1)) {
	    // Write first byte, read next byte
	    writeBits<8+XTRA0,1>(last_mark, b0, allpixels);
	    
	    // Write second byte, read 3rd byte
	    writeBits<8+XTRA0,2>(last_mark, b0, allpixels);
	    allpixels.advanceData();
	    
	    // Write third byte
	    writeBits<8+XTRA0,0>(last_mark, b0, allpixels);
	    
#if (FASTLED_ALLOW_INTERRUPTS == 1)
	    // ets_intr_unlock();
		interrupt_unlock();
#endif
	    
	    allpixels.stepDithering();
	    
#if (FASTLED_ALLOW_INTERRUPTS == 1)
	    // ets_intr_lock();
		interrupt_lock();
	    // if interrupts took longer than 45µs, punt on the current frame
	    if((i32)(__clock_cycles()-last_mark) > 0) {
		if((i32)(__clock_cycles()-last_mark) > (T1+T2+T3+((WAIT_TIME-INTERRUPT_THRESHOLD)*CLKS_PER_US))) { interrupt_unlock(); return 0; }
	    }
#endif
	};
	
	// ets_intr_unlock();
	interrupt_unlock();
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
	++_frame_cnt;
#endif
	return __clock_cycles() - _start;
    }
};
}  // namespace fl

FL_DISABLE_WARNING_POP

#endif
