/** 
 * @file lldiskcache.cpp
 * @brief Implementation of virtual file
 *
 * $LicenseInfo:firstyear=2002&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "linden_common.h"

#include "lldiskcache.h"

#include "llerror.h"
#include "llthread.h"
#include "lltimer.h"
#include "llfasttimer.h"
#include "llmemory.h"

#include <fstream>
#include "lldir.h"

const S32 LLDiskCache::READ			= 0x00000001;
const S32 LLDiskCache::WRITE		= 0x00000002;
const S32 LLDiskCache::READ_WRITE	= 0x00000003;  // LLDiskCache::READ & LLDiskCache::WRITE
const S32 LLDiskCache::APPEND		= 0x00000006;  // 0x00000004 & LLDiskCache::WRITE

static LLTrace::BlockTimerStatHandle FTM_VFILE_WAIT("VFile Wait");

LLDiskCache::LLDiskCache(const LLUUID &file_id, const LLAssetType::EType file_type, S32 mode)
{
	mFileType =	file_type;
	mFileID = file_id;
	mPosition = 0;
    mBytesRead = 0;
    mReadComplete = FALSE;
	mMode = mode;
}

LLDiskCache::~LLDiskCache()
{
}

const std::string assetTypeToString(LLAssetType::EType at)
{
    /**
     * Make use of the C++17 (or is it 14) feature that allows
     * for inline initialization of an std::map<>
     */
    typedef std::map<LLAssetType::EType, std::string> asset_type_to_name_t;
    asset_type_to_name_t asset_type_to_name =
    {
        { LLAssetType::AT_TEXTURE, "TEXTURE" },
        { LLAssetType::AT_SOUND, "SOUND" },
        { LLAssetType::AT_CALLINGCARD, "CALLINGCARD" },
        { LLAssetType::AT_LANDMARK, "LANDMARK" },
        { LLAssetType::AT_SCRIPT, "SCRIPT" },
        { LLAssetType::AT_CLOTHING, "CLOTHING" },
        { LLAssetType::AT_OBJECT, "OBJECT" },
        { LLAssetType::AT_NOTECARD, "NOTECARD" },
        { LLAssetType::AT_CATEGORY, "CATEGORY" },
        { LLAssetType::AT_LSL_TEXT, "LSL_TEXT" },
        { LLAssetType::AT_LSL_BYTECODE, "LSL_BYTECODE" },
        { LLAssetType::AT_TEXTURE_TGA, "TEXTURE_TGA" },
        { LLAssetType::AT_BODYPART, "BODYPART" },
        { LLAssetType::AT_SOUND_WAV, "SOUND_WAV" },
        { LLAssetType::AT_IMAGE_TGA, "IMAGE_TGA" },
        { LLAssetType::AT_IMAGE_JPEG, "IMAGE_JPEG" },
        { LLAssetType::AT_ANIMATION, "ANIMATION" },
        { LLAssetType::AT_GESTURE, "GESTURE" },
        { LLAssetType::AT_SIMSTATE, "SIMSTATE" },
        { LLAssetType::AT_LINK, "LINK" },
        { LLAssetType::AT_LINK_FOLDER, "LINK_FOLDER" },
        { LLAssetType::AT_MARKETPLACE_FOLDER, "MARKETPLACE_FOLDER" },
        { LLAssetType::AT_WIDGET, "WIDGET" },
        { LLAssetType::AT_PERSON, "PERSON" },
        { LLAssetType::AT_MESH, "MESH" },
        { LLAssetType::AT_SETTINGS, "SETTINGS" },
        { LLAssetType::AT_UNKNOWN, "UNKNOWN" }
    };

    asset_type_to_name_t::iterator iter = asset_type_to_name.find(at);
    if (iter != asset_type_to_name.end())
    {
        return iter->second;
    }

    return std::string("UNKNOWN");
}

const std::string idToFilepath(const std::string id, LLAssetType::EType at)
{
    /**
     * For the moment this is just {UUID}_{ASSET_TYPE}.txt but of
     * course,  will be greatly expanded upon
     */
    std::ostringstream ss;
    ss << "00cache_";
    ss << id;
    ss << "_";
    ss << assetTypeToString(at);
    ss << ".txt";

    const std::string filepath = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, ss.str());

    return filepath;
}

// static
bool LLDiskCache::getExists(const LLUUID &file_id, const LLAssetType::EType file_type)
{
	std::string id_str;
	file_id.toString(id_str);
	const std::string filename = idToFilepath(id_str, file_type);

	std::ifstream file(filename, std::ios::binary);
	if (file.is_open())
	{
		file.seekg(0, std::ios::end);
		return file.tellg() > 0;
	}
	return false;
}

// static
bool LLDiskCache::removeFile(const LLUUID &file_id, const LLAssetType::EType file_type)
{
    std::string id_str;
    file_id.toString(id_str);
    const std::string filename = idToFilepath(id_str, file_type);
    
    std::remove(filename.c_str());

    return true;
}

// static
bool LLDiskCache::renameFile(const LLUUID &old_file_id, const LLAssetType::EType old_file_type,
                         const LLUUID &new_file_id, const LLAssetType::EType new_file_type)
{
    std::string old_id_str;
    old_file_id.toString(old_id_str);
    const std::string old_filename = idToFilepath(old_id_str, old_file_type);

    std::string new_id_str;
    new_file_id.toString(new_id_str);
    const std::string new_filename = idToFilepath(new_id_str, new_file_type);

    if (std::rename(old_filename.c_str(), new_filename.c_str()))
    {
        // We would like to return FALSE here indicating the operation
        // failed but the original code does not and doing so seems to
        // break a lot of things so we go with the flow... 
        //return FALSE;
    }

    return TRUE;
}

// static
S32 LLDiskCache::getFileSize(const LLUUID &file_id, const LLAssetType::EType file_type)
{
    std::string id_str;
    file_id.toString(id_str);
    const std::string filename = idToFilepath(id_str, file_type);

    S32 file_size = 0;
    std::ifstream file(filename, std::ios::binary);
    if (file.is_open())
    {
        file.seekg(0, std::ios::end);
        file_size = file.tellg();
    }

    return file_size;
}

BOOL LLDiskCache::read(U8 *buffer, S32 bytes, BOOL async, F32 priority)
{
	BOOL success = TRUE;

    mReadComplete = FALSE;

    std::string id;
    mFileID.toString(id);
    const std::string filename = idToFilepath(id, mFileType);

    std::ifstream file(filename, std::ios::binary);
    if (file.is_open())
    {
        file.seekg(mPosition, std::ios::beg);

        file.read((char*)buffer, bytes);

        if (file)
        {
            mBytesRead = bytes;
        }
        else
        {
            mBytesRead = file.gcount();
        }

        file.close();

        mPosition += mBytesRead;
        if (!mBytesRead)
        {
            success = FALSE;
        }

        mReadComplete = TRUE;
    }

    return success;
}

BOOL LLDiskCache::isReadComplete()
{
    if (mReadComplete)
    {
        return TRUE;
    }

    return FALSE;
}

S32 LLDiskCache::getLastBytesRead()
{
	return mBytesRead;
}

BOOL LLDiskCache::eof()
{
	return mPosition >= getSize();
}

BOOL LLDiskCache::write(const U8 *buffer, S32 bytes)
{
    std::string id_str;
    mFileID.toString(id_str);
    const std::string filename = idToFilepath(id_str, mFileType);

    BOOL success = FALSE;

    if (mMode == APPEND)
    {
        std::ofstream ofs(filename, std::ios::app | std::ios::binary);
        if (ofs)
        {
            ofs.write((const char*)buffer, bytes);

            success = TRUE;
        }
    }
    else
    {
        std::ofstream ofs(filename, std::ios::binary);
        if (ofs)
        {
            ofs.write((const char*)buffer, bytes);

            mPosition += bytes;

            success = TRUE;
        }
    }

    return success;
}

//static
BOOL LLDiskCache::writeFile(const U8 *buffer, S32 bytes, const LLUUID &uuid, LLAssetType::EType type)
{
	LLDiskCache file(uuid, type, LLDiskCache::WRITE);
	file.setMaxSize(bytes);
	return file.write(buffer, bytes);
}

BOOL LLDiskCache::seek(S32 offset, S32 origin)
{
	if (-1 == origin)
	{
		origin = mPosition;
	}

	S32 new_pos = origin + offset;

	S32 size = getSize();

	if (new_pos > size)
	{
		LL_WARNS() << "Attempt to seek past end of file" << LL_ENDL;

		mPosition = size;
		return FALSE;
	}
	else if (new_pos < 0)
	{
		LL_WARNS() << "Attempt to seek past beginning of file" << LL_ENDL;

		mPosition = 0;
		return FALSE;
	}

	mPosition = new_pos;
	return TRUE;
}

S32 LLDiskCache::tell() const
{
	return mPosition;
}

S32 LLDiskCache::getSize()
{
    return LLDiskCache::getFileSize(mFileID, mFileType);
}

S32 LLDiskCache::getMaxSize()
{
    // offer up a huge size since we don't care what the max is 
    return INT_MAX;
}

BOOL LLDiskCache::setMaxSize(S32 size)
{
    // we don't care what the max size is so we do nothing
    // and return true to indicate all was okay
    return TRUE;
}

BOOL LLDiskCache::rename(const LLUUID &new_id, const LLAssetType::EType new_type)
{
    LLDiskCache::renameFile(mFileID, mFileType, new_id, new_type);

    mFileID = new_id;
    mFileType = new_type;

    return TRUE;
}

BOOL LLDiskCache::remove()
{
    LLDiskCache::removeFile(mFileID, mFileType);

    return TRUE;
}

// static
void LLDiskCache::initClass()
{
}

// static
void LLDiskCache::cleanupClass()
{
}

bool LLDiskCache::isLocked()
{
    // I don't think we care about this test since there is no locking
    // TODO: remove this function and calling sites?
    return FALSE;
}

void LLDiskCache::waitForLock()
{
    // TODO: remove this function and calling sites?
}