#include "i386.h"
#include "Task.h"
#include "Syscall.h"
#include "Console.h"

extern "C" void syscall_entry();
extern "C" void syscall_ISR();
extern volatile RegisterDump* syscallRegDump;

asm(
    ".globl syscall_ISR \n"
    ".globl syscallRegDump \n"
    "syscallRegDump: \n"
    ".long 0\n"
    "syscall_ISR:\n"
    "    pusha\n"
    "    pushw %ds\n"
    "    pushw %es\n"
    "    pushw %fs\n"
    "    pushw %gs\n"
    "    pushw %ss\n"
    "    pushw %ss\n"
    "    pushw %ss\n"
    "    pushw %ss\n"
    "    pushw %ss\n"
    "    popw %ds\n"
    "    popw %es\n"
    "    popw %fs\n"
    "    popw %gs\n"
    "    mov %esp, syscallRegDump\n"
    "    call syscall_entry\n"
    "    popw %gs\n"
    "    popw %gs\n"
    "    popw %fs\n"
    "    popw %es\n"
    "    popw %ds\n"
    "    popa\n"
    "    iret\n"
);

static inline dword CAS(dword* mem, dword newval, dword oldval)
{
    dword ret;
    asm volatile(
        "cmpxchgl %2, %1"
        :"=a"(ret), "=m"(*mem)
        :"r"(newval), "m"(*mem), "0"(oldval));
    return ret;
}

class SpinLock {
public:
    SpinLock()
    {
    }

    ~SpinLock()
    {
        unlock();
    }

    void lock()
    {
        volatile dword count = 0;
        for (;;) {
            if (CAS(&m_lock, 1, 0) == 1)
                return;
            ++count;

        }
        if (count)
            kprintf("waited %u in %s\n",count, current->name().characters());
    }

    void unlock()
    {
        // barrier();
        m_lock = 0;
    }

private:
    dword m_lock { 0 };
};

class Locker {
public:
    explicit Locker(SpinLock& l)
        : m_lock(l)
    {
        m_lock.lock();
    }

    ~Locker()
    {
        unlock();
    }

    void unlock()
    {
        m_lock.unlock();
    }

private:
    SpinLock& m_lock;
};

namespace Syscall {

static SpinLock* s_lock;

void initialize()
{
    s_lock = new SpinLock;
    registerUserCallableInterruptHandler(0x80, syscall_ISR);
    kprintf("syscall: int 0x80 handler installed\n");
}

DWORD handle(DWORD function, DWORD arg1, DWORD arg2, DWORD arg3)
{
    Locker locker(*s_lock);
    switch (function) {
    case Syscall::Yield:
        yield();
        break;
    case Syscall::PutCharacter:
        Console::the().putChar(arg1 & 0xff);
        break;
    case Syscall::Sleep:
        //kprintf("syscall: sleep(%d)\n", arg1);
        current->sys$sleep(arg1);
        break;
    case Syscall::Spawn:
        return current->sys$spawn((const char*)arg1);
    case Syscall::PosixOpen:
        //kprintf("syscall: open('%s', %u)\n", arg1, arg2);
        return current->sys$open((const char*)arg1, (size_t)arg2);
    case Syscall::PosixClose:
        //kprintf("syscall: close(%d)\n", arg1);
        return current->sys$close((int)arg1);
    case Syscall::PosixRead:
        //kprintf("syscall: read(%d, %p, %u)\n", arg1, arg2, arg3);
        return current->sys$read((int)arg1, (void*)arg2, (size_t)arg3);
    case Syscall::PosixSeek:
        // FIXME: This has the wrong signature, should be like lseek()
        kprintf("syscall: seek(%d, %d)\n", arg1, arg2);
        return current->sys$seek((int)arg1, (int)arg2);
    case Syscall::PosixKill:
        kprintf("syscall: kill(%d, %d)\n", arg1, arg2);
        return current->sys$kill((pid_t)arg1, (int)arg2);
    case Syscall::PosixGetuid:
        return current->sys$getuid();
    case Syscall::PosixGetgid:
        return current->sys$getgid();
    case Syscall::PosixGetpid:
        return current->sys$getpid();
    case Syscall::PosixExit:
        cli();
        locker.unlock();
        current->sys$exit((int)arg1);
        ASSERT_NOT_REACHED();
        return 0;
    default:
        kprintf("int0x80: Unknown function %x requested {%x, %x, %x}\n", function, arg1, arg2, arg3);
        break;
    }
    return 0;
}

}

void syscall_entry()
{
    auto& regs = *syscallRegDump;
    DWORD function = regs.eax;
    DWORD arg1 = regs.edx;
    DWORD arg2 = regs.ecx;
    DWORD arg3 = regs.ebx;
    regs.eax = Syscall::handle(function, arg1, arg2, arg3);
}