/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 * 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 "../xlslib/record.h"
#include "../xlslib/biffsection.h"
#include "../xlslib/colinfo.h"
#include "../xlslib/continue.h"
#include "../xlslib/datast.h"
#include "../xlslib/err.h"
#include "../xlslib/formula.h"
#include "../xlslib/range.h"
#include "../xlslib/recdef.h"
#include "../xlslib/rectypes.h"
#include "../xlslib/row.h"
#include "../xlslib/sheetrec.h"
#include "../xlslib/workbook.h"

#include "../oledoc/oledoc.h"

#ifdef HAVE_WORKING_ICONV
#include <errno.h>
#endif

using namespace xlslib_core;
using namespace xlslib_strings;


#define CHANGE_DUMPSTATE(state) {				\
		m_PreviousDumpState = m_DumpState;			 \
		m_DumpState = state;						 \
}

/*
 **********************************************************************
 *  workbook class implementation
 **********************************************************************
 */
workbook::workbook() :
	m_GlobalRecords(),
	m_ExprFactory(m_GlobalRecords),
	m_SummaryInfo(),
	m_DocSummaryInfo(),
	m_Sheets(),
	m_DumpState(WB_INIT),
	m_PreviousDumpState(WB_FINISH),
	m_sheetIndex(0),
	m_pCurrentData(NULL),
	m_pContinueRecord(NULL),
	m_ContinueIndex(0),
	m_writeLen(0),
	m_offset(0),
	m_current_sheet(0)
{
#if defined(HAVE_WORKING_ICONV)
	m_GlobalRecords.SetIconvCode("wchar_t");
#endif
}

workbook::~workbook()
{
	if(!m_Sheets.empty()) {
		for(size_t i = 0; i<m_Sheets.size(); i++) {
			delete m_Sheets[i];
		}
	}
	//  CGlobalRecords::Clean();
}

#ifdef HAVE_WORKING_ICONV
int workbook::iconvInType(const char *inType)
{
	int	ret;
	iconv_t	cd;

	cd = iconv_open(UCS_2_INTERNAL, inType);
	if(cd != (iconv_t)(-1)) {
		iconv_close(cd);
		m_GlobalRecords.SetIconvCode(inType);
		ret = 0;
	} else {
		ret = errno;
	}
	return ret;
}
#endif

worksheet* workbook::sheet(const string& sheetname)
{
	u16string str16;

	worksheet* pnewsheet = new worksheet(m_GlobalRecords, m_sheetIndex++);
	m_GlobalRecords.char2str16(sheetname, str16);

	m_Sheets.push_back(pnewsheet);

	// NOTE: Streampos defaults to 0
	// It has to be set somewhere else
	m_GlobalRecords.AddBoundingSheet(0, BSHEET_ATTR_WORKSHEET, str16);

	// Return a pointer to the just added sheet
	return m_Sheets.back();
}

worksheet* workbook::sheet(const ustring& sheetname)
{
	u16string str16;

	worksheet* pnewsheet = new worksheet(m_GlobalRecords, m_sheetIndex++);
	m_GlobalRecords.wide2str16(sheetname, str16);

	m_Sheets.push_back(pnewsheet);

	// NOTE: Streampos defaults to 0
	// It has to be set somewhere else
	m_GlobalRecords.AddBoundingSheet(0, BSHEET_ATTR_WORKSHEET, str16);

	// Return a pointer to the just added sheet
	return m_Sheets.back();
}

worksheet* workbook::GetSheet(unsigned16_t sheetnum)
{
	if(sheetnum < m_Sheets.size()) {
		return m_Sheets[sheetnum];
	} else {
		return NULL;
	}
}

expression_node_factory_t& workbook::GetFormulaFactory(void)
{
	return m_ExprFactory;
}

font_t* workbook::font(const string& name)
{
	font_t* newfont = new font_t(m_GlobalRecords);
	newfont->SetName(name);
	m_GlobalRecords.AddFont(newfont);

	return newfont;
}

font_t* workbook::font(unsigned8_t fontnum)
{
	return m_GlobalRecords.fontdup(fontnum);
}

format_t* workbook::format(const string& formatstr)
{
	u16string str16;
	format_t* newformat;

	m_GlobalRecords.char2str16(formatstr, str16);

	newformat = new format_t(m_GlobalRecords, str16);
	m_GlobalRecords.AddFormat(newformat);

	return newformat;
}

format_t* workbook::format(const ustring& formatstr)
{
	u16string str16;
	format_t* newformat;

	m_GlobalRecords.wide2str16(formatstr, str16);

	newformat = new format_t(m_GlobalRecords, str16);
	m_GlobalRecords.AddFormat(newformat);

	return newformat;
}

xf_t* workbook::xformat(void)
{
	xf_t* newxf = new xf_t(m_GlobalRecords, true);      // bool userXF=true, bool isCell=true, bool isMasterXF=false

	return newxf;
}

xf_t* workbook::xformat(font_t* fnt)
{
	xf_t* newxf = new xf_t(m_GlobalRecords, true);
	newxf->SetFont(fnt);

	return newxf;
}

xf_t* workbook::xformat(format_t* fmt)
{
	xf_t* newxf = new xf_t(m_GlobalRecords, true);
	newxf->SetFormat(fmt);

	return newxf;
}

xf_t* workbook::xformat(font_t* fnt, format_t* fmt)
{
	xf_t* newxf = new xf_t(m_GlobalRecords, true);
	newxf->SetFont(fnt);
	newxf->SetFormat(fmt);

	return newxf;
}

bool workbook::setColor(unsigned8_t r, unsigned8_t g, unsigned8_t b, unsigned8_t idx)
{
	return m_GlobalRecords.SetColor(r, g, b, idx);
}

bool workbook::property(property_t prop, const string& content)
{
	// who gets it?
	if(prop >= PROP_LAST) {return false; }

	if(property2summary[prop] > 0) {
		return m_SummaryInfo.property(prop, content);
	} else
	if(property2docSummary[prop] > 0) {
		return m_DocSummaryInfo.property(prop, content);
	} else {
		return false;
	}
}

void workbook::windPosition(unsigned16_t horz, unsigned16_t vert) { m_GlobalRecords.GetWindow1().SetPosition(horz, vert); }
void workbook::windSize(unsigned16_t width, unsigned16_t height) { m_GlobalRecords.GetWindow1().SetSize(width, height); }
void workbook::firstTab(unsigned16_t fTab) { m_GlobalRecords.GetWindow1().SetFirstTab(fTab); }
void workbook::tabBarWidth(unsigned16_t width) { m_GlobalRecords.GetWindow1().SetTabBarWidth(width); }

int workbook::Dump(const string& filename)
{
	Sheets_Vector_Itor_t sBegin, sEnd, sIter;
	size_t cells;
	string name;
	int	errors;
	COleDoc dst;

	if(m_Sheets.empty()) {
		return GENERAL_ERROR;
	}

	// pre-allocate an approximation of what will be needed to store the data objects
	sBegin	= m_Sheets.begin();
	sEnd	= m_Sheets.end();
	cells	= 0;
	/*
	 *  Since it's VERY costly to redimension the cell unit store vector when
	 *  we're using lightweight CUnitStore elements et al
	 *  we do our utmost best to estimate the total amount of storage units
	 *  required to 'dump' our spreadsheet. The estimate should be conservative,
	 *  but not too much. After all, we're attempting to reduce the memory
	 *  footprint for this baby when we process multi-million cell spreadsheets...
	 */
	for(sIter=sBegin; sIter<sEnd; ++sIter) {
		// add a number of units for each worksheet,
		cells += (*sIter)->EstimateNumBiffUnitsNeeded();
	}
	// global units:
	cells += this->m_GlobalRecords.EstimateNumBiffUnitsNeeded4Header();
	cells += 1000; // safety margin

	XTRACE2("ESTIMATED: total storage unit count: ", cells);
#if OLE_DEBUG
	std::cerr << "ESTIMATED: total unit count: " << cells << std::endl;
#endif

	errors = dst.Open(filename);

	if(errors == NO_ERRORS)	{
		CDataStorage biffdata(cells);
		CUnit* precorddata;
		bool keep = true;

		do {
			precorddata = DumpData(biffdata);

			if(precorddata != NULL) {
				biffdata += precorddata;
				// and we can already discard any previous units at lower backpatch levels
				biffdata.FlushLowerLevelUnits(precorddata);
			} else {
				keep = false;
			}
		} while(keep);

		dst.AddFile("/Workbook", &biffdata);

		CDataStorage summarydata;
		name = (char)0x05;
		name += "SummaryInformation";
		m_SummaryInfo.DumpData(summarydata);
		dst.AddFile(name, &summarydata);

		CDataStorage docdata;
		name = (char)0x05;
		name += "DocumentSummaryInformation";
		m_DocSummaryInfo.DumpData(docdata);
		dst.AddFile(name, &docdata);

		errors = dst.DumpOleFile();
		dst.Close();
	}
	return errors;
}

CUnit* workbook::DumpData(CDataStorage &datastore)
{
	bool repeat = false;

	XTRACE("\nworkbook::DumpData");

	do {
		switch(m_DumpState) {
		case WB_INIT:
			XTRACE("\tWB_INIT");

			m_writeLen = 0;
			m_current_sheet = 0;
			m_offset = 0;

			CHANGE_DUMPSTATE(WB_GLOBALRECORDS);

			repeat = true;
			break;

		case WB_GLOBALRECORDS:
			XTRACE("\tGLOBALRECORDS");

			m_pCurrentData = m_GlobalRecords.DumpData(datastore);
			if(m_pCurrentData == NULL) {
				m_offset = m_writeLen;
				m_writeLen = 0;
				//Last_BOF_offset = 0;

				repeat = true;
				CHANGE_DUMPSTATE(WB_SHEETS);
			} else {
				m_writeLen += m_pCurrentData->GetDataSize();
				// Do nothing. Continue in this state.
				repeat = false;
			}
			break;

		case WB_SHEETS:
		{
			XTRACE("\tSHEETS");

			//printf("DUMP SHEETS WITH DATASIZE=%ld m_offset=%ld m_writeLen=%ld\n", datastore.GetDataSize(), m_offset, m_writeLen );
			m_pCurrentData = m_Sheets[m_current_sheet]->DumpData(datastore, m_offset, m_writeLen /*, Last_BOF_offset*/);   // writelen passed as its cumulatively increased
			if(m_pCurrentData == NULL) {
				Boundsheet_Vect_Itor_t bs = m_GlobalRecords.GetBoundSheetAt(m_current_sheet);

				(*bs)->SetSheetStreamPosition(m_offset);

				if((m_current_sheet+1) < (unsigned16_t)m_Sheets.size()) { // [i_a]
					// Update the m_offset for the next sheet
					m_offset += m_writeLen;
					m_writeLen = 0;
					m_current_sheet++;
				} else {
					// I'm done with all the sheets
					CHANGE_DUMPSTATE(WB_FINISH);
				}
				repeat = true;
			} else {
				m_writeLen += m_pCurrentData->GetDataSize();
				repeat = false;
			}
		}  break;

		case WB_FINISH:
			XTRACE("\tFINISH");

			repeat = false;
			m_pCurrentData  = NULL;

			CHANGE_DUMPSTATE(WB_INIT);

			break;

		case WB_CONTINUE_REC:
			XTRACE("\tCONTINUE-REC");

			if(m_ContinueIndex == 0) {
				//Create a new data unit containing the max data size
				m_ContinuesRealRecordSize = datastore.Clip((CRecord*)m_pCurrentData);
				//m_pContinueRecord->SetValueAt(MAX_RECORD_SIZE-4,2);
				m_ContinueIndex++;

				return m_pCurrentData;
			} else {
				//Delete_Pointer(m_pContinueRecord);

				// Get a pointer to the next chunk of data
				const unsigned8_t* pdata = (((CRecord*)m_pCurrentData)->GetRecordDataBuffer()) + m_ContinueIndex*MAX_RECORD_SIZE;

				// Get the size of the chunk of data (that is the MAX_REC_SIZE except by the last one)
				size_t csize = 0;

				if((m_ContinuesRealRecordSize/MAX_RECORD_SIZE) > m_ContinueIndex) {
					csize = MAX_RECORD_SIZE;
					m_ContinueIndex++;

					m_pContinueRecord = datastore.MakeCContinue(m_pCurrentData, pdata, csize);
					if(m_PreviousDumpState == WB_SHEETS) { m_writeLen += RECORD_HEADER_SIZE; }
					return m_pContinueRecord;
				} else {
					CUnit *unit = m_pCurrentData;
					csize = m_ContinuesRealRecordSize - m_ContinueIndex * MAX_RECORD_SIZE;

					// Restore the previous state (*Don't use the macro*)
					m_DumpState = m_PreviousDumpState;
					m_PreviousDumpState = WB_CONTINUE_REC;
					m_pCurrentData = NULL;
					m_ContinueIndex = 0;
					// done with it now, so can delete it
					// Delete_Pointer(m_pCurrentData);

					if(csize) {
						m_pContinueRecord = datastore.MakeCContinue(unit, pdata, csize);
						if(m_PreviousDumpState == WB_SHEETS) { m_writeLen += RECORD_HEADER_SIZE; }
						return m_pContinueRecord;
					} else {
						repeat = true;
					}
				}
			}

			break;

		default:
			XTRACE("\tDEFAULT");

			break;
		}

		if(m_pCurrentData != NULL) {
			// SST Table most likely record to exceed size, but its handled now in the record itself (breaks have to occur at defined places)
			// Should only happen with single cells having data > MAX_RECORD_SIZE. Have no idea if this works or not (DFH)
			if(!((CRecord*)m_pCurrentData)->AlreadyContinued() && ((CRecord*)m_pCurrentData)->GetRecordDataSize() > MAX_RECORD_SIZE && m_DumpState !=
			   WB_CONTINUE_REC) {
				// Save the current dump state and change to the CONTINUE Record state
				CHANGE_DUMPSTATE(WB_CONTINUE_REC);
				//printf("ALREADY=%d dataSize=%lu MAX=%d (dumpState == CONTINUE) = %d\n", ((CRecord*)m_pCurrentData)->AlreadyContinued(), ((CRecord*)m_pCurrentData)->GetRecordDataSize(), MAX_RECORD_SIZE ,m_DumpState == WB_CONTINUE_REC);

				m_ContinueIndex = 0;

				repeat = true;
			}
		}
	} while(repeat);

	return m_pCurrentData;
}