#include "CSQLiteFileSystemExtension.h"

#include <lf/os/CFile.h>
#include <lf/os/CMemoryReadFile.h>
#include <lf/os/CFileSystem.h>
#include <lf/LfLog.h>

using namespace lf;
using namespace os;

CSQLiteFileSystemExtension::CSQLiteFileSystemExtension()
	: filesystem(0)
{
	//ctor
}

CSQLiteFileSystemExtension::~CSQLiteFileSystemExtension()
{
	//dtor
	for (u32 i = 0; i < DBs.size(); ++i)
	{
		sqlite3_close(DBs[i]);
	}

	if (filesystem)
	{
		filesystem->drop();
	}
}

void CSQLiteFileSystemExtension::setOwningFileSystem(CFileSystem* fs)
{
	assert(fs);
	
	if (filesystem)
	{
		filesystem->drop();
	}
	fs->grab();
	filesystem = fs;
}

const c8* CSQLiteFileSystemExtension::getFileSystemIdentifier() const
{
	static const c8* id = "db";
	return id;
}

bool CSQLiteFileSystemExtension::existFile(const c8* filename, core::stringc *path)
{
	if(path)
	{
		*path = "";
	}

	for (u32 i=0; i<DBs.size(); ++i)
	{
		c8* data = 0;
		u32 size = 0;
		selectRow(DBs[i], filename, &data, &size);
		
		if (data)
		{
			delete[] data;
			return true;
		}
	}
	return false;
}

CFile* CSQLiteFileSystemExtension::createAndOpenFile(const c8* filename)
{
	for (u32 i=0; i<DBs.size(); ++i)
	{
		c8* data = 0;
		u32 size = 0;
		selectRow(DBs[i], filename, &data, &size);

		if (data)
		{
			return new CMemoryReadFile(data, size, filename, true);
		}
	}
	return 0;
}

CFile* CSQLiteFileSystemExtension::createAndWriteFile(const c8* filename, bool append)
{
	// no write-support (yet)
	return 0;
}

bool CSQLiteFileSystemExtension::addPath(const c8* filename, bool ignoreCase, bool ignorePaths)
{
	assert(filesystem);
	
	// TODO: add support for encrypted filesystems ("archive.zip:password")
	
	sqlite3* db = 0;
	if (sqlite3_open(filename, &db) == SQLITE_OK)
	{
		DBs.push_back(db);
		return true;
	}

	CLFLog::getInstance().log(lf::log::ELS_IO, lf::log::ELL_WARN, "Could not open database: %s", filename);
	return false;
}

bool CSQLiteFileSystemExtension::removePath(const c8* filename)
{
	// not yet supported
	return false;
}

void CSQLiteFileSystemExtension::selectRow(sqlite3* db, const c8* filename, c8** data, u32* size)
{
	// TODO: select "like"
	
	static const c8* sql = "select data from filesystem where name = ?1";
	sqlite3_stmt* stm = 0;
	s32 rc = 0;
	
	if (sqlite3_prepare(db, sql, -1, &stm, 0) == SQLITE_OK)
	{
		do
		{
			sqlite3_bind_text(stm, 1, filename, strlen(filename), 0);
			rc = sqlite3_step(stm);
			if (rc == SQLITE_ROW)
			{
				*size = sqlite3_column_bytes(stm, 0);
				*data = new c8[*size];
				memcpy(*data, sqlite3_column_blob(stm, 0), *size);
				break;
			}
		} while (rc == SQLITE_SCHEMA);
		sqlite3_finalize(stm);
	}
	else
	{
		CLFLog::getInstance().log(lf::log::ELS_USER1, lf::log::ELL_ERROR, "PREPARE failed: %s", sqlite3_errmsg(db));
	}
}