/*
 * Copyright (C) 2009 Niek Linnenbank
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <FreeNOS/System.h>
#include <FreeNOS/Kernel.h>
#include <FreeNOS/Config.h>
#include <FreeNOS/Process.h>
#include <FreeNOS/ProcessEvent.h>
#include <Log.h>
#include "ProcessCtl.h"

void interruptNotify(CPUState *st, Process *p)
{
    ProcessEvent event;

    event.type   = InterruptEvent;
    event.number = IRQ_REG(st);

    p->raiseEvent(&event);
}

Error ProcessCtlHandler(ProcessID procID,
                        ProcessOperation action,
                        Address addr,
                        Address output)
{
    Process *proc = ZERO;
    ProcessInfo *info = (ProcessInfo *) addr;
    ProcessManager *procs = Kernel::instance->getProcessManager();
    Timer *timer;
    Arch::MemoryMap map;

    DEBUG("#" << procs->current()->getID() << " " << action << " -> " << procID << " (" << addr << ")");

    // TODO: Verify memory address

    // Does the target process exist?
    if(action != GetPID && action != Spawn)
    {
        if (procID == SELF)
            proc = procs->current();
        else if (!(proc = procs->get(procID)))
            return API::NotFound;
    }
    // Handle request
    switch (action)
    {
    case Spawn:
        proc = procs->create(addr, map);
        proc->setParent(procs->current()->getID());
        return proc->getID();
    
    case KillPID:
        procs->remove(proc, addr); // Addr contains the exit status
        procs->schedule();
        break;

    case GetPID:
        return procs->current()->getID();

    case GetParent:
        return procs->current()->getParent();

    case Schedule:
        procs->schedule();
        break;

    case Resume:
        // increment wakeup counter and set process ready
        proc->wakeup();
        break;

    case WatchIRQ:
        Kernel::instance->hookIntVector(IRQ(addr), (InterruptHandler *)interruptNotify, (ulong)proc);
        break;

    case EnableIRQ:
        Kernel::instance->enableIRQ(addr, true);
        break;

    case DisableIRQ:
        Kernel::instance->enableIRQ(addr, false);
        break;
    
    case InfoPID:
        info->id    = proc->getID();
        info->state = proc->getState();
        info->userStack     = proc->getUserStack();
        info->kernelStack   = proc->getKernelStack();
        info->pageDirectory = proc->getPageDirectory();
        info->parent = proc->getParent();
        break;

    case WaitPID:
        procs->current()->setWait(proc->getID());
        procs->current()->setState(Process::Waiting);
        procs->schedule();
        return procs->current()->getWait(); // contains the exit status of the other process

    case InfoTimer:
        if (!(timer = Kernel::instance->getTimer()))
            return API::NotFound;
        
        timer->getCurrent((Timer::Info *) addr); // TODO: check access...
        break;

    /*    
    case WaitTimer:
        procs->current()->setSleepTimer((const Timer::Info *)addr); // TODO: check access...
        procs->current()->setState(Process::Sleeping);
        procs->schedule();
        // TODO: set a Timer::Info field for the process. Then when scheduling, the process
        // will only be allowed to run until after the Timer::Info time has arrived (for sleep).
        break;
     */

    case EnterSleep:
        // only sleeps the process if no pending wakeups
        if (procs->current()->sleep((Timer::Info *)addr) == Process::Success)
            procs->schedule();

        if (output && ((timer = Kernel::instance->getTimer())))
            timer->getCurrent((Timer::Info *) output); // TODO: check access...
        break;

    case SetStack:
        proc->setUserStack(addr);
        break;
    }
    return API::Success;
}

Log & operator << (Log &log, ProcessOperation op)
{
    switch (op)
    {
        case Spawn:     log.append("Spawn"); break;
        case KillPID:   log.append("KillPID"); break;
        case GetPID:    log.append("GetPID"); break;
        case GetParent: log.append("GetParent"); break;
        case WatchIRQ:  log.append("WatchIRQ"); break;
        case EnableIRQ: log.append("EnableIRQ"); break;
        case DisableIRQ:log.append("DisableIRQ"); break;
        case InfoPID:   log.append("InfoPID"); break;
        case WaitPID:   log.append("WaitPID"); break;
        case InfoTimer: log.append("InfoTimer"); break;
        case EnterSleep: log.append("EnterSleep"); break;
        case Schedule:  log.append("Schedule"); break;
        case Resume:    log.append("Resume"); break;
        case SetStack:  log.append("SetStack"); break;
        default:        log.append("???"); break;
    }
    return log;
}