/*
 * Copyright (C) 2015 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/API.h>
#include <Index.h>
#include <MemoryBlock.h>
#include <MemoryChannel.h>
#include <SplitAllocator.h>
#include "Process.h"
#include "ProcessEvent.h"

Process::Process(ProcessID id, Address entry, bool privileged, const MemoryMap &map)
    : m_id(id), m_map(map), m_shares(id)
{
    m_state         = Stopped;
    m_kernelStack   = 0;
    m_userStack     = 0;
    m_pageDirectory = 0;
    m_parent        = 0;
    m_waitId        = 0;
    m_wakeups       = 0;
    m_entry         = entry;
    m_privileged    = privileged;
    m_memoryContext = ZERO;
    m_kernelChannel = new MemoryChannel;
    MemoryBlock::set(&m_sleepTimer, 0, sizeof(m_sleepTimer));
}
    
Process::~Process()
{
    delete m_kernelChannel;

    if (m_memoryContext)
    {
        m_memoryContext->releaseRegion(MemoryMap::UserData);
        m_memoryContext->releaseRegion(MemoryMap::UserHeap);
        m_memoryContext->releaseRegion(MemoryMap::UserStack);
        m_memoryContext->releaseRegion(MemoryMap::UserPrivate);
        delete m_memoryContext;
    }
}

ProcessID Process::getID() const
{
    return m_id;
}

ProcessID Process::getParent() const
{
    return m_parent;
}

ProcessID Process::getWait() const
{
    return m_waitId;
}

Process::State Process::getState() const
{
    return m_state;
}

ProcessShares & Process::getShares()
{
    return m_shares;
}

const Timer::Info * Process::getSleepTimer() const
{
    return &m_sleepTimer;
}

Address Process::getPageDirectory() const
{
    return m_pageDirectory;
}

Address Process::getUserStack() const
{
    return m_userStack;
}

Address Process::getKernelStack() const
{
    return m_kernelStack;
}

MemoryContext * Process::getMemoryContext()
{
    return m_memoryContext;
}

bool Process::isPrivileged() const
{
    return m_privileged;
}

void Process::setState(Process::State st)
{
    m_state = st;
}

void Process::setParent(ProcessID id)
{
    m_parent = id;
}

void Process::setWait(ProcessID id)
{
    m_waitId = id;
}

void Process::setSleepTimer(const Timer::Info *sleepTimer)
{
    MemoryBlock::copy(&m_sleepTimer, sleepTimer, sizeof(m_sleepTimer));
}

void Process::setPageDirectory(Address addr)
{
    m_pageDirectory = addr;
}

void Process::setUserStack(Address addr)
{
    m_userStack = addr;
}

void Process::setKernelStack(Address addr)
{
    m_kernelStack = addr;
}

Process::Result Process::raiseEvent(ProcessEvent *event)
{
    // Write the message. Be sure to flush the caches because
    // the kernel has mapped the channel pages separately in low memory.
    m_kernelChannel->write(event);
    m_kernelChannel->flush();

    // Wakeup the Process, if needed
    return wakeup();
}

Process::Result Process::initialize()
{
    Memory::Range range;
    Address paddr, vaddr;
    Arch::Cache cache;

    // Allocate two pages for the kernel event channel
    if (Kernel::instance->getAllocator()->allocateLow(PAGESIZE*2, &paddr) != Allocator::Success)
        return OutOfMemory;

    // Translate to virtual address in kernel low memory
    vaddr = (Address) Kernel::instance->getAllocator()->toVirtual(paddr);
    MemoryBlock::set((void *)vaddr, 0, PAGESIZE*2);
    cache.cleanData(vaddr);
    cache.cleanData(vaddr + PAGESIZE);

    // Map data and feedback pages in userspace
    range.phys   = paddr;
    range.access = Memory::User | Memory::Readable;
    range.size   = PAGESIZE * 2;
    m_memoryContext->findFree(range.size, MemoryMap::UserPrivate, &range.virt);
    m_memoryContext->mapRange(&range);

    // Remap the feedback page with write permissions
    m_memoryContext->unmap(range.virt + PAGESIZE);
    m_memoryContext->map(range.virt + PAGESIZE,
                         range.phys + PAGESIZE, Memory::User | Memory::Readable | Memory::Writable);

    // Create shares entry
    m_shares.setMemoryContext(m_memoryContext);
    m_shares.createShare(KERNEL_PID, Kernel::instance->getCoreInfo()->coreId, 0, range.virt, range.size);

    // Setup the kernel event channel
    m_kernelChannel->setMode(Channel::Producer);
    m_kernelChannel->setMessageSize(sizeof(ProcessEvent));
    m_kernelChannel->setVirtual(vaddr, vaddr + PAGESIZE);

    return Success;
}

Process::Result Process::wakeup()
{
    m_wakeups++;

    if (m_state != Running)
        m_state = Ready;

    MemoryBlock::set(&m_sleepTimer, 0, sizeof(m_sleepTimer));
    return Success;
}

Process::Result Process::sleep(Timer::Info *timer)
{
    if (!m_wakeups)
    {
        m_state = Sleeping;
        
        if (timer)
            MemoryBlock::copy(&m_sleepTimer, timer, sizeof(m_sleepTimer));

        return Success;
    }
    m_wakeups = 0;
    return WakeupPending;
}

bool Process::operator==(Process *proc)
{
    return proc->getID() == m_id;
}