#include "ProcFileSystem.h"
#include "Task.h"
#include <VirtualFileSystem/VirtualFileSystem.h>
#include "system.h"

static ProcFileSystem* s_the;

ProcFileSystem& ProcFileSystem::the()
{
    ASSERT(s_the);
    return *s_the;
}

RetainPtr<ProcFileSystem> ProcFileSystem::create()
{
    return adopt(*new ProcFileSystem);
}

ProcFileSystem::ProcFileSystem()
{
    s_the = this;
}

ProcFileSystem::~ProcFileSystem()
{
}

void ProcFileSystem::addProcess(Task& task)
{
    ASSERT_INTERRUPTS_DISABLED();
    char buf[16];
    ksprintf(buf, "%d", task.pid());
    auto dir = addFile(createDirectory(buf));
    m_pid2inode.set(task.pid(), dir.index());
    addFile(createGeneratedFile("vm", [&task] {
        InterruptDisabler disabler;
        char* buffer;
        auto stringImpl = StringImpl::createUninitialized(80 + task.regionCount() * 80, buffer);
        memset(buffer, 0, stringImpl->length());
        char* ptr = buffer;
        ptr += ksprintf(ptr, "BEGIN       END         SIZE        NAME\n");
        for (auto& region : task.regions()) {
            ptr += ksprintf(ptr, "%x -- %x    %x    %s\n",
                region->linearAddress.get(),
                region->linearAddress.offset(region->size - 1).get(),
                region->size,
                region->name.characters());
        }
        *ptr = '\0';
        return ByteBuffer::copy((byte*)buffer, ptr - buffer);
    }), dir.index());
    addFile(createGeneratedFile("stack", [&task] {
        InterruptDisabler disabler;
        auto& syms = ksyms();
        dword firstKsymAddress = syms.first().address;
        dword lastKsymAddress = syms.last().address;
        struct RecognizedSymbol {
            dword address;
            const char* name;
            dword offset;
        };
        Vector<RecognizedSymbol> recognizedSymbols;
        size_t bytesNeeded = 0;
        for (dword* stackPtr = (dword*)task.stackPtr(); (dword)stackPtr < task.stackTop(); ++stackPtr) {
            if (*stackPtr < firstKsymAddress || *stackPtr > lastKsymAddress)
                continue;
            const char* name = nullptr;
            unsigned offset = 0;
            for (unsigned i = 0; i < syms.size(); ++i) {
                if (*stackPtr < syms[i+1].address) {
                    name = syms[i].name.characters();
                    offset = *stackPtr - syms[i].address;
                    bytesNeeded += syms[i].name.length() + 8 + 16;
                    break;
                }
            }
            recognizedSymbols.append({ *stackPtr, name, offset });
        }
        auto buffer = ByteBuffer::createUninitialized(bytesNeeded);
        char* ptr = (char*)buffer.pointer();
        for (auto& symbol : recognizedSymbols) {
            kprintf("%p  %s +%u\n", symbol.address, symbol.name, symbol.offset);
        }
        buffer.trim(ptr - (char*)buffer.pointer());
        return buffer;
    }), dir.index());
}

void ProcFileSystem::removeProcess(Task& task)
{
    ASSERT_INTERRUPTS_DISABLED();
    auto pid = task.pid();
    auto it = m_pid2inode.find(pid);
    ASSERT(it != m_pid2inode.end());
    bool success = removeFile((*it).value);
    ASSERT(success);
    m_pid2inode.remove(pid);
}

bool ProcFileSystem::initialize()
{
    SyntheticFileSystem::initialize();

    addFile(createGeneratedFile("mounts", [] {
        InterruptDisabler disabler;
        auto buffer = ByteBuffer::createUninitialized(VirtualFileSystem::the().mountCount() * 80);
        char* ptr = (char*)buffer.pointer();
        VirtualFileSystem::the().forEachMount([&ptr] (auto& mount) {
            auto& fs = mount.fileSystem();
            ptr += ksprintf(ptr, "%s @ ", fs.className());
            if (!mount.host().isValid())
                ptr += ksprintf(ptr, "/\n", fs.className());
            else
                ptr += ksprintf(ptr, "%u:%u\n", mount.host().fileSystemID(), mount.host().index());
        });
        buffer.trim(ptr - (char*)buffer.pointer());
        return buffer;
    }));

    addFile(createGeneratedFile("kmalloc", [] {
        InterruptDisabler disabler;
        auto buffer = ByteBuffer::createUninitialized(128);
        char* ptr = (char*)buffer.pointer();
        ptr += ksprintf(ptr, "alloc: %u\nfree:  %u\n", sum_alloc, sum_free);
        buffer.trim(ptr - (char*)buffer.pointer());
        return buffer;
    }));

    addFile(createGeneratedFile("summary", [] {
        InterruptDisabler disabler;
        auto tasks = Task::allTasks();
        auto buffer = ByteBuffer::createUninitialized(tasks.size() * 256);
        char* ptr = (char*)buffer.pointer();
        ptr += ksprintf(ptr, "PID    OWNER      STATE  PPID  NSCHED      FDS    NAME\n");
        for (auto* task : tasks) {
            ptr += ksprintf(ptr, "%w   %w:%w  %b     %w  %x    %w   %s\n",
                task->pid(),
                task->uid(),
                task->gid(),
                task->state(),
                task->parentPID(),
                task->timesScheduled(),
                task->fileHandleCount(),
                task->name().characters());
        }
        *ptr = '\0';
        buffer.trim(ptr - (char*)buffer.pointer());
        return buffer;
    }));
    return true;
}

const char* ProcFileSystem::className() const
{
    return "procfs";
}