/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 * This file is part of xlslib -- A multiplatform, C/C++ library
 * for dynamic generation of Excel(TM) files.
 *
 * Copyright 2004 Yeico S. A. de C. V. All Rights Reserved.
 * Copyright 2008-2013 David Hoerl All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 *    1. Redistributions of source code must retain the above copyright notice, this list of
 *       conditions and the following disclaimer.
 *
 *    2. Redistributions in binary form must reproduce the above copyright notice, this list
 *       of conditions and the following disclaimer in the documentation and/or other materials
 *       provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY David Hoerl ''AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL David Hoerl OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include <string>

#include "../common/stringtok.h"

#include "../xlslib/record.h"
#include "../oledoc/olefs.h"
#include "../xlslib/datast.h"

using namespace xlslib_core;
using namespace xlslib_strings;

/*
 ***********************************
 *  COleFileSystem class Implementation
 ***********************************
 */

COleFileSystem::COleFileSystem() :
	m_RootEntry((signed32_t) 0, "Root Entry"),
	m_nProperty_Count(0)
{
	m_RootEntry.SetType(PTYPE_ROOT);
	m_RootEntry.SetSize(0);
	m_RootEntry.SetPreviousIndex(PLINK_EMPTY);
	m_RootEntry.SetNextIndex(PLINK_EMPTY);
	m_RootEntry.SetChildIndex(PLINK_EMPTY);
	m_RootEntry.SetStartBlock(PBLOCK_END);
	m_RootEntry.SetColor(PROPERTY_COLOR_NODE_BLACK);
	m_RootEntry.SetDataPointer(NULL);

	m_RootEntry.SetCreatedSecs(PPT_DFLT_SECS1);
	m_RootEntry.SetCreatedDays(PPT_DFLT_DAYS1);
	m_RootEntry.SetModifiedSecs(PPT_DFLT_SECS2);
	m_RootEntry.SetModifiedDays(PPT_DFLT_DAYS2);
}

COleFileSystem::~COleFileSystem()
{
}

int COleFileSystem::GetNode(string const &path, Tree_Level_Itor_t& node)
{
	StringList_t path_list;

	stringtok(path_list, path, "/");

	int retval = SearchNode(&m_RootEntry, path_list, node);

	// Delete dynamically created strings of path_list
	// anyway the list is deleted inside SearchNode...
	for (StringListItor_t pl = path_list.begin(); pl != path_list.end(); pl++) {
		delete *pl;
	}
	return retval;
}

int COleFileSystem::SearchNode(COleProp* base_node, StringList_t& path_list, Tree_Level_Itor_t& node_level)
{
	int errcode = FS_INVALID_PATH;

	if(!((base_node->m_Child_List).empty())) {
		for (StringListItor_t node_name = path_list.begin(); node_name != path_list.end(); ++node_name) {
			for(node_level = (base_node->m_Child_List).begin(); node_level != (base_node->m_Child_List).end(); node_level++) {
				if (**node_name == (*node_level)->GetName()) {
					delete path_list.front();
					path_list.pop_front(); // Remove the found element from path
					if(path_list.empty()) { // If it was the last element return it
						return FS_NO_ERRORS;
					} else {
						// Recursively continue the search
						return SearchNode(*node_level, path_list, node_level);
					}
				}
			}
		}
	}

	return errcode;
}

int COleFileSystem::AddDirectory(string const &dir_path)
{
	int errcode = NO_ERRORS;
	StringList_t path_list;

	stringtok(path_list, dir_path, "/");
	errcode = AddNode(&m_RootEntry, path_list);

	// Delete dynamically created strings of path_list
	for (StringListItor_t pl = path_list.begin(); pl != path_list.end(); pl++) {
		delete *pl;
	}

	if(errcode == FS_NO_ERRORS) {
		Tree_Level_Itor_t newnode;
		GetNode(dir_path, newnode);
		(*newnode)->SetChildIndex(PLINK_EMPTY);
		(*newnode)->SetType(PTYPE_DIRECTORY);
		(*newnode)->SetSize(0);
		(*newnode)->SetColor(PROPERTY_COLOR_NODE_BLACK);
		(*newnode)->SetDataPointer(NULL);

		(*newnode)->SetCreatedSecs(PPT_DFLT_SECS1);
		(*newnode)->SetCreatedDays(PPT_DFLT_DAYS1);
		(*newnode)->SetModifiedSecs(PPT_DFLT_SECS2);
		(*newnode)->SetModifiedDays(PPT_DFLT_DAYS2);
	}
	return errcode;
}

#define MIN_DATA_SIZE (0x1000)

// TODO: Change the DataStorage pass-argument (???)

int COleFileSystem::AddFile(string const &dir_path, CDataStorage* pdata)
{
	int errcode = NO_ERRORS;
	StringList_t path_list;

	// NOTE: Token analysis can be done inside of AddNode:
	stringtok(path_list, dir_path, "/");
	errcode = AddNode(&m_RootEntry, path_list);

	// Delete dynamically created strings of path_list
	for (StringListItor_t pl = path_list.begin(); pl != path_list.end(); pl++) {
		delete *pl;
	}

	if(errcode == FS_NO_ERRORS) {
		Tree_Level_Itor_t newnode;
		GetNode(dir_path, newnode);
		(*newnode)->SetType(PTYPE_FILE);
		(*newnode)->SetChildIndex(PLINK_EMPTY);


		// Calculate the trail data size needed to complete a BIG_BLOCK
		size_t trail_size = (pdata->GetDataSize() % BIG_BLOCK_SIZE) ? (BIG_BLOCK_SIZE - (pdata->GetDataSize() % BIG_BLOCK_SIZE)) : 0;

		// This library won't use Small Blocks, so all data elements shall be >0x1000
		if ((trail_size + pdata->GetDataSize()) < MIN_DATA_SIZE) {
			trail_size = MIN_DATA_SIZE  - pdata->GetDataSize();
			(*newnode)->SetSize(MIN_DATA_SIZE);
		} else {
			// The size stored in the node is the actual size of the data (not the filled-to-bigblock one)
			(*newnode)->SetSize(pdata->GetDataSize() + trail_size);
		}

		// create the trail data unit.
		CUnit* ptraildata = pdata->MakeCUnit();
		ptraildata->AddFixedDataArray(0x00, trail_size);
		(*pdata) += ptraildata;

		(*newnode)->SetDataPointer(pdata);
		(*newnode)->SetColor(PROPERTY_COLOR_NODE_BLACK);
		(*newnode)->SetCreatedSecs(PPT_DFLT_SECS1);
		(*newnode)->SetCreatedDays(PPT_DFLT_DAYS1);
		(*newnode)->SetModifiedSecs(PPT_DFLT_SECS2);
		(*newnode)->SetModifiedDays(PPT_DFLT_DAYS2);
	}
	return errcode;
}

/*
 ***********************************
 *  Some special adding-node cases:
 *  - The path to reach the node doesn't exist
 *  - The the node already exists
 ***********************************
 */
int COleFileSystem::AddNode(COleProp* base_node, StringList_t& path_list)
{
	int errcode;

	if(!(base_node->m_Child_List).empty()) {
		for(Tree_Level_Itor_t node_child = (base_node->m_Child_List).begin();
			node_child != (base_node->m_Child_List).end(); node_child++) {
			if((*node_child)->GetName() == **path_list.begin()) {
				delete path_list.front();
				path_list.pop_front(); // Remove the found element from path
				return AddNode(*node_child, path_list);
			}
		}
	}
	//if the path element wasn't found, the program gets here
	//... and we have two possible reasons:
	// 1. The path isn't correct, so no node is created and an error msg have to be returned
	//    (one of the intermediate nodes is empty or doesn't exist: there are more than one path elements left)
	// 2. The node is the new one we want to create.

	// if the size of the path is 0, the node already existed
	if(path_list.size() != 1) {
		if (path_list.size() == 0) {
			errcode = FS_NODE_ALREADY_EXISTS;
		} else {
			errcode = FS_INVALID_PATH;
		}
	} else {
		unsigned8_t base_node_type = base_node->GetType();
		if(base_node_type == PTYPE_DIRECTORY || base_node_type == PTYPE_ROOT) {
			COleProp* newnode = new COleProp(++m_nProperty_Count, **path_list.begin());
			size_t childnum = (base_node->m_Child_List).size();

			if(!(base_node->m_Child_List).empty()) { //if this is the first child of the node...
				Tree_Level_Itor_t lastnode = (base_node->m_Child_List).end();
				lastnode--;

				if(1 == childnum) {
					base_node->SetChildIndex(newnode->GetIndex()); // The 2nd child is the entry always
					newnode->SetPreviousIndex((*lastnode)->GetIndex()); // The previous is the only element of the list
				} else {
					(*lastnode)->SetNextIndex(newnode->GetIndex());
					newnode->SetPreviousIndex(PLINK_EMPTY); // there is no previous
				}
				newnode->SetNextIndex(PLINK_EMPTY); // there is no next
				newnode->SetChildIndex(PLINK_EMPTY); // there is no child
			} else {
				base_node->SetChildIndex(m_nProperty_Count); // the new one is the child
				newnode->SetPreviousIndex(PLINK_EMPTY); // there is no previous
				newnode->SetNextIndex(PLINK_EMPTY); // there is no next
				newnode->SetChildIndex(PLINK_EMPTY); // there is no child
			}

			(base_node->m_Child_List).push_back(newnode);

			errcode = FS_NO_ERRORS;
		} else {
			errcode = FS_NODE_NOT_A_DIRECTORY;
		}
	}
	return errcode;
}

void COleFileSystem::GetAllNodes(NodeList_t& node_list)
{
	GetAllNodesList(node_list, &m_RootEntry);
	SortList(node_list);
}

void COleFileSystem::GetAllNodesList(NodeList_t& node_list, COleProp* base_node)
{
	if(!(base_node->m_Child_List).empty()) {
		for(Tree_Level_Itor_t child_node = (base_node->m_Child_List).begin();
			child_node != (base_node->m_Child_List).end(); child_node++ ) {
			GetAllNodesList(node_list, (*child_node));
			node_list.push_back((*child_node));
		}
	} else {
		return;
	}
}

static inline bool oleCompare (const COleProp *left, const COleProp *right)
{
	return left->GetIndex() < right->GetIndex();
}

void COleFileSystem::SortList(NodeList_t& node_list)
{
	//printf("sort len = %d\n", node_list.size() );
	sort(node_list.begin(), node_list.end(), oleCompare);       // stable_sort Compare
}

size_t COleFileSystem::GetTotalDataSize()
{
	NodeList_t node_list;
	GetAllNodes(node_list);
	size_t total_size = 0;

	for(NodeList_Itor_t i = node_list.begin(); i != node_list.end(); i++) {
		if((*i)->GetType() == PTYPE_FILE) {
			total_size += (*i)->GetDataPointer()->GetDataSize();
		}
	}
	return total_size;
}

unsigned32_t COleFileSystem::GetNumDataFiles()
{
	NodeList_t node_list;
	GetAllNodes(node_list);
	unsigned32_t total_files = 0;

	for(NodeList_Itor_t i = node_list.begin(); i != node_list.end(); i++) {
		if((*i)->GetType() == PTYPE_FILE) {
			total_files++;
		}
	}

	return total_files;
}

COleProp& COleFileSystem::GetRootEntry()
{
	return m_RootEntry;
}