#include "X86InterruptAdvisor.h"
#include "../../Util/Log.h"
#include "../../Util/Console.h"

extern "C" void _int_handler(Oxygen::Kernel::Processor::InterruptState state)
{
    Oxygen::Kernel::Processor::X86::X86InterruptAdvisor::getInstance()->handle(state);
};

/**
 * Assembler code to start interrupt handling.
 *
 * @param idtPointer Pointer to the IDT table pointer.
 */
extern "C" void _int_table_flush(unsigned int idtPointer);

/**
 * Array of pointers to asm interrupt handler.
 */
extern unsigned int _int_handlers[];

namespace Oxygen { namespace Kernel { namespace Processor { namespace X86 {

    using namespace Oxygen::Kernel::Util;

    X86InterruptAdvisor *X86InterruptAdvisor::getInstance()
    {
        return &instance;  
    };
    
    X86InterruptAdvisor X86InterruptAdvisor::instance;
    
    //X86InterruptAdvisor::~X86InterruptAdvisor()
    //{};

    void X86InterruptAdvisor::handle(InterruptState state)
    {
        // Handler exists?
        InterruptHandler *handler = handlers[state.interruptNumber];
        
        // Debug code
        Console::getInstance()->writeHex((unsigned int) handler);
        Console::getInstance()->write("\n");
        Console::getInstance()->setHardwareCursor();
        
        if (handler == 0) return;
     
        // Debug code
        Log::getInstance()->log(Log::Info, "Interrupt to handle!");
        
        // Call handler
        handlers[state.interruptNumber]->handle(state);
    };

    void X86InterruptAdvisor::setUp()
    {
        // Initialize pointer
        pointer.limit = sizeof(struct X86InterruptPointer) * 256 - 1;
        pointer.base = (unsigned int) &entries;
        
        // Initialize gates
        for (unsigned short i = 0; i < 256; ++i) 
            setGate(
                (unsigned char) i,
                (unsigned int) ::_int_handlers[i],
                0x08,
                (i == 3 || i == INT_SYSCALL) // Userspace?
                    ? 0xEE : 0x8E
                );
        
        // Flush
        flush();
    };
    
    void X86InterruptAdvisor::setGate(unsigned char number, unsigned int base, unsigned short selector, unsigned char flags)
    {
        entries[number].baseLow = base & 0xFFFF;
        entries[number].baseHigh = (base >> 16) & 0xFFFF;
        
        entries[number].selector = selector;
        entries[number].zero = 0;
        
        entries[number].flags = flags;
    };
    
    void X86InterruptAdvisor::flush()
    {
        ::_int_table_flush((unsigned int) &pointer);
    };
    
    bool X86InterruptAdvisor::setHandler(unsigned char interrupt, InterruptHandler *handler)
    {
        handlers[interrupt] = handler;
        return true;
    };

}}}}
