#include <renderd7/FileSystem.hpp>
#include <3ds.h>
#include <cstring>

const char* RenderD7::FileSystem::GetPhysfsError()
{
    return PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode());
}

std::string RenderD7::FileSystem::Normalize(const std::string& input)
{
    std::string out;
    bool seenSep = false, isSep = false;

    for (size_t i = 0; i < input.size(); ++i)
    {
        isSep = (input[i] == '/');

        if (!isSep || !seenSep)
            out += input[i];

        seenSep = isSep;
    }

    return out;
}

void RenderD7::FileSystem::Initialize()
{
    RenderD7::FileSystem::savePath = "";
}

int RenderD7::FileSystem::Init(const char* argv)
{
    return PHYSFS_init(argv);
}

bool RenderD7::FileSystem::SetSource(const char* source)
{
    if (!PHYSFS_isInit())
        return false;

    std::string searchPath = source;
    if (!PHYSFS_mount(searchPath.c_str(), NULL, 1))
        return false;

    return true;
}

bool RenderD7::FileSystem::SetIdentity(const char* name, bool append)
{
    if (!PHYSFS_isInit())
        return false;

    std::string old = RenderD7::FileSystem::savePath;

    RenderD7::FileSystem::savePath = RenderD7::FileSystem::Normalize(RenderD7::FileSystem::GetUserDirectory() + "/save/" + name);
    printf("Save Path set to %s\n", savePath.c_str());

    if (!old.empty())
        PHYSFS_unmount(old.c_str());

    int success = PHYSFS_mount(savePath.c_str(), NULL, append);
    printf("Save Path mounted %d\n", success);

    PHYSFS_setWriteDir(nullptr);

    return true;
}

std::string RenderD7::FileSystem::GetSaveDirectory()
{
    return RenderD7::FileSystem::Normalize(RenderD7::FileSystem::GetUserDirectory() + "/save");
}

bool RenderD7::FileSystem::SetupWriteDirectory()
{
    if (!PHYSFS_isInit())
        return false;

    if (RenderD7::FileSystem::savePath.empty())
        return false;

    std::string tmpWritePath     = RenderD7::FileSystem::savePath;
    std::string tmpDirectoryPath = RenderD7::FileSystem::savePath;

    if (RenderD7::FileSystem::savePath.find(RenderD7::FileSystem::GetUserDirectory()) == 0)
    {
        tmpWritePath     = RenderD7::FileSystem::GetUserDirectory();
        tmpDirectoryPath = savePath.substr(RenderD7::FileSystem::GetUserDirectory().length());

        /* strip leading '/' characters from the path we want to create */
        size_t startPosition = tmpDirectoryPath.find_first_not_of('/');

        if (startPosition != std::string::npos)
            tmpDirectoryPath = tmpDirectoryPath.substr(startPosition);
    }

    if (!PHYSFS_setWriteDir(tmpWritePath.c_str()))
    {
        printf("Failed to set write dir to %s\n", tmpWritePath.c_str());
        return false;
    }

    if (!RenderD7::FileSystem::CreateDirectory(tmpDirectoryPath.c_str()))
    {
        printf("Failed to create dir %s\n", tmpDirectoryPath.c_str());
        /* clear the write directory in case of error */
        PHYSFS_setWriteDir(nullptr);
        return false;
    }

    if (!PHYSFS_setWriteDir(savePath.c_str()))
    {
        printf("Failed to set write dir to %s\n", savePath.c_str());
        return false;
    }

    if (!PHYSFS_mount(savePath.c_str(), nullptr, 0))
    {
        printf("Failed to mount write dir (%s)\n", RenderD7::FileSystem::GetPhysfsError());
        /* clear the write directory in case of error */
        PHYSFS_setWriteDir(nullptr);
        return false;
    }

    return true;
}

std::string RenderD7::FileSystem::GetUserDirectory()
{
    return RenderD7::FileSystem::Normalize(PHYSFS_getPrefDir("npi-d7", "renderd7"));
}

bool RenderD7::FileSystem::GetInfo(const char* filename, RenderD7::FileSystem::Info& info)
{
    if (!PHYSFS_isInit())
        return false;

    PHYSFS_Stat stat = {};

    if (!PHYSFS_stat(filename, &stat))
        return false;

    info.mod_time = std::min<int64_t>(stat.modtime, RenderD7::FileSystem::MAX_STAMP);
    info.size     = std::min<int64_t>(stat.filesize, RenderD7::FileSystem::MAX_STAMP);

    if (stat.filetype == PHYSFS_FILETYPE_REGULAR)
        info.type = RenderD7::FileSystem::FileType_File;
    else if (stat.filetype == PHYSFS_FILETYPE_DIRECTORY)
        info.type = RenderD7::FileSystem::FileType_Directory;
    else if (stat.filetype == PHYSFS_FILETYPE_SYMLINK)
        info.type = RenderD7::FileSystem::FileType_SymLink;
    else
        info.type = RenderD7::FileSystem::FileType_Other;

    return true;
}

void RenderD7::FileSystem::GetDirectoryItems(const char* path, std::vector<std::string>& items)
{
    if (!PHYSFS_isInit())
        return;

    char** results = PHYSFS_enumerateFiles(path);

    if (results == nullptr)
        return;

    for (char** item = results; *item != 0; item++)
        items.push_back(*item);

    PHYSFS_freeList(results);
}

bool RenderD7::FileSystem::OpenFile(File& file, const char* name, FileMode mode)
{
    if (mode == FileMode_Closed)
        return false;

    if (!PHYSFS_isInit())
        return false;

    if (file.handle)
        RenderD7::FileSystem::CloseFile(file);

    if (mode == FileMode_Read && !PHYSFS_exists(name))
    {
        printf("Could not open file %s, does not exist.\n", name);
        return false;
    }

    if ((mode == FileMode_Write) &&
        (PHYSFS_getWriteDir() == nullptr && RenderD7::FileSystem::SetupWriteDirectory()))
    {
        printf("Could not set write directory.\n");
        return false;
    }

    PHYSFS_getLastErrorCode();

    switch (mode)
    {
        case FileMode_Read:
            file.handle = PHYSFS_openRead(name);
            break;
        case FileMode_Write:
            file.handle = PHYSFS_openWrite(name);
            break;
        default:
            break;
    }

    if (!file.handle)
    {
        const char* error = RenderD7::FileSystem::GetPhysfsError();

        if (error == nullptr)
            error = "unknown error";

        printf("Could not open file %s (%s)\n", name, error);

        return false;
    }

    file.mode = mode;

    return true;
}

bool RenderD7::FileSystem::CloseFile(File& file)
{
    if (file.handle == nullptr || !PHYSFS_close(file.handle))
        return false;

    file.handle = nullptr;

    return true;
}

bool RenderD7::FileSystem::CreateDirectory(const char* name)
{
    if (!PHYSFS_isInit())
        return false;

    if (PHYSFS_getWriteDir() == nullptr && !RenderD7::FileSystem::SetupWriteDirectory())
        return false;

    if (!PHYSFS_mkdir(name))
        return false;

    return true;
}

int64_t RenderD7::FileSystem::ReadFile(File& file, void* destination, int64_t size)
{
    if (!file.handle || file.mode != FileMode_Read)
    {
        printf("File is not opened for reading.\n");
        return 0;
    }

    if (size > file.GetSize())
        size = file.GetSize();
    else if (size < 0)
    {
        printf("Invalid read size %lld\n", size);
        return 0;
    }

    return PHYSFS_readBytes(file.handle, destination, (PHYSFS_uint64)size);
}

bool RenderD7::FileSystem::WriteFile(File& file, const void* data, int64_t size)
{
    if (!file.handle || file.mode != FileMode_Write)
    {
        printf("File is not opened for writing.\n");
        return false;
    }

    int64_t written = PHYSFS_writeBytes(file.handle, data, (PHYSFS_uint64)size);

    if (written != size)
        return false;

    return true;
}