#pragma once
#include "threads.hpp"
#include <stdio.hpp>

namespace JabyEngine {
    namespace Callback {
        namespace internal {
            static void execute_callback(Thread::Handle thread_handle, uint32_t parm, uint8_t irq_bit_pending, uint8_t irq, uint8_t last_cmd) {
                if(CurrentThread::is_me(MainThread::Handle)) {
                    CurrentThread::replace_with(thread_handle);
                    CurrentThread::force_a0(parm);
                }

                else {
                    //printf("%i +> %i +> %i\n", irq_bit_pending, irq, last_cmd);
                }
                //printf("C\n");
                SysCall::ReturnFromException();
            }

            static uint32_t resume_callback(Thread::Handle handle) {
                SysCall::ChangeThread(handle);
                asm("sw $a0, %0" : "=m"(handle));
                return handle;
            }

            namespace VSync {
                static constexpr size_t StackSize = 64;

                extern SysCall::ThreadHandle thread_handle;
                extern uint32_t              stack[StackSize];
                void                         routine();

                static void [[deprecated("Currently not in use")]] execute() {
                    execute_callback(VSync::thread_handle, 0, 0, 0, 0);
                }
            }

            namespace CD {
                static constexpr size_t StackSize = 256;

                extern Thread::Handle thread_handle;
                extern uint32_t       stack[StackSize];
                void                  routine(uint32_t irq);

                static void execute(uint32_t irq, uint8_t irq_bit_pending, uint8_t irq2, uint8_t last_cmd) {
                    execute_callback(CD::thread_handle, irq, irq_bit_pending, irq2, last_cmd);
                }

                static uint32_t resume() {
                    return resume_callback(MainThread::Handle);
                }
            }
        }
    }
}