/*
 * (c) Copyright Ascensio System SIA 2010-2023
 *
 * This program is a free software product. You can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License (AGPL)
 * version 3 as published by the Free Software Foundation. In accordance with
 * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
 * that Ascensio System SIA expressly excludes the warranty of non-infringement
 * of any third-party rights.
 *
 * This program is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
 * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
 *
 * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
 * street, Riga, Latvia, EU, LV-1050.
 *
 * The  interactive user interfaces in modified source and object code versions
 * of the Program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU AGPL version 3.
 *
 * Pursuant to Section 7(b) of the License you must retain the original Product
 * logo when distributing the program. Pursuant to Section 7(e) we decline to
 * grant you any rights under trademark law for use of our trademarks.
 *
 * All the Product's GUI elements, including illustrations and icon sets, as
 * well as technical writing content are licensed under the terms of the
 * Creative Commons Attribution-ShareAlike 4.0 International. See the License
 * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 */

#include "Oox2OdfConverter.h"

#include "Converter.h"

#include "../../Common/utils.h"

#include "XlsxConverter.h"
#include "DocxConverter.h"
#include "PptxConverter.h"

#include "../Format/office_document.h"
#include "../Format/odf_conversion_context.h"
#include "../Format/odf_text_context.h"
#include "../Format/odf_drawing_context.h"

#include "../Format/style_text_properties.h"
#include "../Format/style_paragraph_properties.h"

#include "../../../OOXML/XlsxFormat/Xlsx.h"
#include "../../../OOXML/DocxFormat/Docx.h"
#include "../../../OOXML/DocxFormat/DocxFlat.h"
#include "../../../OOXML/PPTXFormat/Presentation.h"

#include "../../../OOXML/DocxFormat/App.h"
#include "../../../OOXML/DocxFormat/Core.h"

#include "../../../OOXML/DocxFormat/Logic/Vml.h"
#include "../../../OOXML/DocxFormat/Diagram/DiagramDrawing.h"
#include "../../../OOXML/DocxFormat/Diagram/DiagramData.h"
#include "../../../OOXML/DocxFormat/Drawing/DrawingExt.h"
#include "../../../OOXML/DocxFormat/Math/oMathPara.h"

#include "../../../OOXML/PPTXFormat/Logic/Shape.h"
#include "../../../OOXML/PPTXFormat/Logic/CxnSp.h"
#include "../../../OOXML/PPTXFormat/Logic/GraphicFrame.h"
#include "../../../OOXML/PPTXFormat/Logic/Pic.h"
#include "../../../OOXML/PPTXFormat/Logic/SmartArt.h"
#include "../../../OOXML/PPTXFormat/Logic/Effects/AlphaModFix.h"
#include "../../../OOXML/PPTXFormat/Logic/Effects/Grayscl.h"
#include "../../../OOXML/PPTXFormat/Logic/Effects/Duotone.h"
#include "../../../OOXML/PPTXFormat/Logic/HeadingVariant.h"

#include "../../../OOXML/XlsxFormat/Worksheets/Sparkline.h"
#include "../../../OfficeCryptReader/source/CryptTransform.h"
#include "../../../DesktopEditor/common/Directory.h"
#include "../../../DesktopEditor/common/SystemUtils.h"

using namespace cpdoccore;

namespace Oox2Odf
{
    Converter::Converter(const std::wstring & path, const std::wstring  & type, const std::wstring & fontsPath, bool bTemplate, const std::wstring & tempPath)
    { 
		impl_ = NULL;
		
        if (type == _T("text"))			impl_ = new DocxConverter(path, bTemplate);
        if (type == _T("spreadsheet"))	impl_ = new XlsxConverter(path, bTemplate);
        if (type == _T("presentation"))	impl_ = new PptxConverter(path, bTemplate);

		if (impl_)
		{
			impl_->set_fonts_directory(fontsPath);
			impl_->set_temp_directory(tempPath);
		}
	}

	Converter::~Converter() 
    {
		if (impl_ )delete impl_ ;
	}

    bool Converter::convert()
    {
		if (!impl_)return false;
		
		return impl_->convertDocument();
    }
    bool Converter::write(const std::wstring & out_path, const std::wstring & temp_path, const std::wstring & password, const std::wstring & documentID) const
    {
		if (!impl_)return false;
		
		return impl_->write(out_path, temp_path, password, documentID);
    }

/////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool OoxConverter::write(const std::wstring & out_path, const std::wstring & temp_path, const std::wstring & password, const std::wstring & documentID)
{
	if (!output_document)return false;

	if (false == documentID.empty())
	{
		output_document->add_binary(L"documentID", NSFile::CUtf8Converter::GetUtf8StringFromUnicode(documentID));
	}
	
	if (password.empty())
	{
		output_document->write(out_path, false);
	}
	else
	{
		//encrypt files
		std::wstring temp_folder = NSDirectory::CreateDirectoryWithUniqueName(temp_path);

		if (false == temp_folder.empty())
		{
			output_document->write(temp_folder, true);

			encrypt_document(password, temp_folder, out_path);

			output_document->write_manifest(out_path);

			NSDirectory::DeleteDirectory(temp_folder);
		}
	}
	return true;
}
std::wstring EncodeBase64(const std::string & value)
{
	int nLength = 0;
	char *pData = NULL;
	std::wstring result;

	NSFile::CBase64Converter::Encode((BYTE*)value.c_str(), (int)value.length(), pData, nLength, NSBase64::B64_BASE64_FLAG_NOCRLF);
	if (pData)
	{
		result = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pData, nLength);
		delete []pData; pData = NULL;
	}
	return result;
}
bool OoxConverter::encrypt_document (const std::wstring &password, const std::wstring & srcPath, const std::wstring & dstPath)
{
	odf_writer::package::manifect_file* manifest =  output_document->get_manifest();
	if (!manifest) return false;

	odf_writer::rels *rels = manifest->get_rels();

	for (size_t i = 0; i < rels->relationships_.size(); i++)
	{
		if (rels->relationships_[i].target_ == L"/") continue;

		std::wstring inp_file_name = srcPath + FILE_SEPARATOR_STR + rels->relationships_[i].target_;
		std::wstring out_file_name = dstPath + FILE_SEPARATOR_STR + rels->relationships_[i].target_;

		if (std::wstring::npos != rels->relationships_[i].target_.find(L"/"))
		{
			std::vector<std::wstring> refs;
			boost::algorithm::split(refs, rels->relationships_[i].target_, boost::algorithm::is_any_of(L"/"), boost::algorithm::token_compress_on);

			std::wstring folder = dstPath;
			for (size_t j = 0; j < refs.size() - 1; j++)
			{
				folder += FILE_SEPARATOR_STR + refs[j];
				NSDirectory::CreateDirectory(folder);
			}
		}
		
		encrypt_file(password, inp_file_name, out_file_name, rels->relationships_[i].encryption_, rels->relationships_[i].size_);
	}
	return true;
}
bool OoxConverter::encrypt_file (const std::wstring &password, const std::wstring & srcPath, const std::wstring & dstPath, std::wstring &encrypt_info, int &size)
{
	CRYPT::ODFEncryptor		encryptor;
	CRYPT::_odfCryptData	cryptData;

	std::wstring sApplication = NSSystemUtils::GetEnvVariable(NSSystemUtils::gc_EnvMethodEncrypt);

//	if (sApplication == L"Weak")
//	{
////-----------------------
////blowfish
//		cryptData.cipherAlgorithm		= CRYPT_METHOD::Blowfish_CFB;
//		cryptData.start_hashAlgorithm	= CRYPT_METHOD::SHA1;
//		cryptData.start_hashSize		= 20;
//
//		cryptData.spinCount	= 1024;
//		cryptData.keySize	= 7;//16;
//
//		cryptData.checksum_size = 1024;
//		cryptData.checksum_hashAlgorithm = CRYPT_METHOD::SHA1;
//	}
//	else
	{
//-----------------------
//aes
		cryptData.cipherAlgorithm		= CRYPT_METHOD::AES_CBC;
		cryptData.start_hashAlgorithm	= CRYPT_METHOD::SHA256;
		cryptData.start_hashSize		= 32;

		cryptData.spinCount	= 100000;
		cryptData.keySize	= 32;

		cryptData.checksum_size = 1024;
		cryptData.checksum_hashAlgorithm = CRYPT_METHOD::SHA256;
	}
//-----------------------
	NSFile::CFileBinary file;

	if (false == file.OpenFile(srcPath))
		return false;

	DWORD	size_inp = 0;
	size = file.GetFileSize();

	unsigned char* data_inp	= new unsigned char[size];
	unsigned char* data_out	= NULL;
	
	file.ReadFile(data_inp, size, size_inp); 
	file.CloseFile();	
//------------------------------------------------------------------------------------------
	encryptor.SetCryptData(cryptData);
	
	int size_out = encryptor.Encrypt(password, data_inp, size_inp, data_out);
	delete []data_inp;
	
	encryptor.GetCryptData(cryptData);
//------------------------------------------------------------------------------------------------------------
	if (!data_out) return false;

	if (false == file.CreateFileW(dstPath)) return false;
	
	file.WriteFile(data_out, size_out);
	file.CloseFile();
	delete []data_out;
//------------------------------------------------------------------------------------------
	odf_writer::office_element_ptr encryption_elm;
	odf_writer::create_element (L"manifest", L"encryption-data", encryption_elm, odf_context());

	encryption_elm->create_child_element(L"manifest", L"algorithm");
	encryption_elm->create_child_element(L"manifest", L"key-derivation");
	encryption_elm->create_child_element(L"manifest", L"start-key-generation");

	odf_writer::manifest_encryption_data* encryption_data = dynamic_cast<odf_writer::manifest_encryption_data*>(encryption_elm.get());
	
	if (!encryption_data) return false;

	odf_writer::manifest_algorithm*				algorithm = dynamic_cast<odf_writer::manifest_algorithm*>(encryption_data->algorithm_.get());
	odf_writer::manifest_key_derivation*		key_derivation = dynamic_cast<odf_writer::manifest_key_derivation*>(encryption_data->key_derivation_.get());
	odf_writer::manifest_start_key_generation*	start_key_generation = dynamic_cast<odf_writer::manifest_start_key_generation*>(encryption_data->start_key_generation_.get());

	if (key_derivation)
	{
		key_derivation->salt_ = EncodeBase64(cryptData.saltValue);	
		key_derivation->iteration_count_ = cryptData.spinCount;	
		key_derivation->key_size_ = cryptData.keySize;	
	}
//------------------------------------------------------------------------------------------
	if (start_key_generation)
	{
		switch(cryptData.start_hashAlgorithm)
		{
		case CRYPT_METHOD::SHA1:	start_key_generation->start_key_generation_name_ = L"SHA1"; break;
		case CRYPT_METHOD::SHA256:	start_key_generation->start_key_generation_name_ = L"http://www.w3.org/2000/09/xmldsig#sha256"; break;
		case CRYPT_METHOD::SHA512:	start_key_generation->start_key_generation_name_ = L"http://www.w3.org/2000/09/xmldsig#sha512"; break;
		}
		start_key_generation->key_size_ = cryptData.start_hashSize;
	}
//------------------------------------------------------------------------------------------
	if (algorithm)
	{
		algorithm->initialisation_vector_ = EncodeBase64(cryptData.initializationVector);

		switch(cryptData.cipherAlgorithm)
		{		
		case CRYPT_METHOD::AES_CBC:			algorithm->algorithm_name_ = L"http://www.w3.org/2001/04/xmlenc#aes256-cbc"; break;
		case CRYPT_METHOD::Blowfish_CFB:	algorithm->algorithm_name_ = L"Blowfish CFB"; break;
		}
	}
//------------------------------------------------------------------------------------------
	if (encryption_data)
	{
		encryption_data->checksum_= EncodeBase64(cryptData.checksum);

		switch(cryptData.checksum_hashAlgorithm)
		{	
		case CRYPT_METHOD::SHA1:	encryption_data->checksum_type_ = L"SHA1"; break;
		case CRYPT_METHOD::SHA256:	encryption_data->checksum_type_ = L"urn:oasis:names:tc:opendocument:xmlns:manifest:1.0#sha256"; break;
		case CRYPT_METHOD::SHA512:	encryption_data->checksum_type_ = L"urn:oasis:names:tc:opendocument:xmlns:manifest:1.0#sha512"; break;
		}
		if (cryptData.checksum_size == 1024)
		{
			if (cryptData.checksum_hashAlgorithm == CRYPT_METHOD::SHA1)
				encryption_data->checksum_type_ += L"/1K";
			else
				encryption_data->checksum_type_ += L"-1k";
		}
	}
//------------------------------------------------------------------------------------------
	std::wstringstream strm;
	encryption_elm->serialize(strm);

	encrypt_info = strm.str();
	
	return true;
}
void OoxConverter::set_temp_directory(const std::wstring & tempPath)
{
	if (odf_context() == NULL) return;

	odf_context()->set_temp_directory(tempPath);
}
void OoxConverter::set_fonts_directory(const std::wstring &fontsPath)
{
	if (odf_context() == NULL) return;

    odf_context()->set_fonts_directory(fontsPath);
}
void OoxConverter::convert_meta(OOX::CApp *app, OOX::CCore *core)
{
	if (app)
	{

	}
	if (core)
	{
		if (core->m_sCreator.IsInit())
			odf_context()->add_meta(L"dc", L"creator", *core->m_sCreator);
		if (core->m_sCreated.IsInit())
			odf_context()->add_meta(L"meta", L"creation-date", *core->m_sCreated);
		if (core->m_sKeywords.IsInit())
			odf_context()->add_meta(L"meta", L"keyword", *core->m_sKeywords);
		if (core->m_sTitle.IsInit())
			odf_context()->add_meta(L"dc", L"title", *core->m_sTitle);
		if (core->m_sDescription.IsInit())
			odf_context()->add_meta(L"dc", L"description", *core->m_sDescription);
		if (core->m_sLanguage.IsInit())
			odf_context()->add_meta(L"dc", L"language", *core->m_sLanguage);
	}
}
void OoxConverter::convert_customs(OOX::IFileContainer* container)
{
	if (!container) return;
	smart_ptr<PPTX::CustomProperties> customProperties = container->Find(OOX::FileTypes::CustomProperties).smart_dynamic_cast<PPTX::CustomProperties>();

	if (false == customProperties.IsInit()) return;

	for (auto prop : customProperties->m_arProperties)
	{
		if (prop.m_strName.IsInit())
		{
			std::wstring content;
			if (prop.m_oContent.IsInit())
			{
				switch (prop.m_oContent->getVariantType())
				{
				case PPTX::Logic::vtLpstr:
				case PPTX::Logic::vtLpwstr:
				case PPTX::Logic::vtBstr:
				{
					if (prop.m_oContent->m_strContent.IsInit())
						content = *prop.m_oContent->m_strContent;
				}break;
				case PPTX::Logic::vtI1:
				case PPTX::Logic::vtI2:
				case PPTX::Logic::vtI4:
				case PPTX::Logic::vtI8:
				case PPTX::Logic::vtDecimal:
				case PPTX::Logic::vtInt:
				{
					if (prop.m_oContent->m_iContent.IsInit())
						content = std::to_wstring(*prop.m_oContent->m_iContent);
				}break;
				case PPTX::Logic::vtUi1:
				case PPTX::Logic::vtUi2:
				case PPTX::Logic::vtUi4:
				case PPTX::Logic::vtUi8:
				{
					if (prop.m_oContent->m_uContent.IsInit())
						content = std::to_wstring(*prop.m_oContent->m_uContent);
				}break;
				case PPTX::Logic::vtR4:
				{
					if (prop.m_oContent->m_dContent.IsInit())
						content = std::to_wstring(*prop.m_oContent->m_dContent);
				}break;
				case PPTX::Logic::vtBool:
				{
					if (prop.m_oContent->m_bContent.IsInit())
						content = std::to_wstring(*prop.m_oContent->m_bContent);
				}break;
				}
			}
			odf_context()->add_meta_user_define(*prop.m_strName, content);

		}
		//nullable_string m_strFmtid;
		//nullable_string m_strLinkTarget;
	}
}
void OoxConverter::convert(OOX::WritingElement  *oox_unknown)
{
	try
	{
		if (oox_unknown == NULL)return;

		switch(oox_unknown->getType())
		{
			case OOX::et_graphicFrame:
			{
				convert(dynamic_cast<PPTX::Logic::GraphicFrame*>(oox_unknown));
			}break;
			case OOX::et_pic:
			{
				convert(dynamic_cast<PPTX::Logic::Pic*>(oox_unknown));
			}break;
			case OOX::et_dgm_DiagrammParts:
			{
				convert(dynamic_cast<PPTX::Logic::SmartArt*>(oox_unknown));
			}break;
			case OOX::et_a_Shape:
			case OOX::et_p_Shape:
			case OOX::et_dsp_Shape:
			case OOX::et_w_Shape:
			{
				convert(dynamic_cast<PPTX::Logic::Shape*>(oox_unknown));
			}break;
			case OOX::et_p_ShapeTree:
			case OOX::et_a_GroupShape:
			case OOX::et_w_GroupShape:
			case OOX::et_lc_LockedCanvas:
			{
				convert(dynamic_cast<PPTX::Logic::SpTree *>(oox_unknown));				
			}break;
			case OOX::et_cxnSp:
			{
				convert(dynamic_cast<PPTX::Logic::CxnSp*>(oox_unknown));
			}break;
			case OOX::et_a_prstGeom:
			{
				convert(dynamic_cast<PPTX::Logic::PrstGeom*>(oox_unknown));
			}break;
			case OOX::et_a_custGeom:
			{
				convert(dynamic_cast<PPTX::Logic::CustGeom*>(oox_unknown));
			}break;
			case OOX::et_a_ahXY:
			{
				convert(dynamic_cast<PPTX::Logic::AhXY*>(oox_unknown));
			}break;
			case OOX::et_a_ahPolar:
			{
				convert(dynamic_cast<PPTX::Logic::AhPolar*>(oox_unknown));
			}break;
			case OOX::et_a_lnTo:
			{
				convert(dynamic_cast<PPTX::Logic::LineTo*>(oox_unknown));
			}break;
			case OOX::et_a_moveTo:
			{
				convert(dynamic_cast<PPTX::Logic::MoveTo*>(oox_unknown));
			}break;
			case OOX::et_a_arcTo:
			{
				convert(dynamic_cast<PPTX::Logic::ArcTo*>(oox_unknown));
			}break;
			case OOX::et_a_quadBezTo:
			{
				convert(dynamic_cast<PPTX::Logic::QuadBezTo*>(oox_unknown));
			}break;
			case OOX::et_a_cubicBezTo:
			{
				convert(dynamic_cast<PPTX::Logic::CubicBezTo*>(oox_unknown));
			}break;
			case OOX::et_a_close:
			{
				convert(dynamic_cast<PPTX::Logic::Close*>(oox_unknown));
			}break;
			case OOX::et_p_r:
			case OOX::et_a_r:
			{
				convert(dynamic_cast<PPTX::Logic::Run*>(oox_unknown));
			}break;
			case OOX::et_p_br:
			case OOX::et_a_br:
			{
				convert(dynamic_cast<PPTX::Logic::Br*>(oox_unknown));
			}break;
			case OOX::et_a_fld:
			case OOX::et_p_fld:
			{
				convert(dynamic_cast<PPTX::Logic::Fld*>(oox_unknown));
			}break;
			case OOX::et_p_MathPara:
			{
				convert(dynamic_cast<PPTX::Logic::MathParaWrapper*>(oox_unknown));
			}break;
			case OOX::et_a_effectStyle:
			{
				convert(dynamic_cast<PPTX::Logic::EffectStyle*>(oox_unknown));
			}break;
			case OOX::et_a_alphaModFix:
			{
				convert(dynamic_cast<PPTX::Logic::AlphaModFix*>(oox_unknown));
			}break;
			case OOX::et_a_blur:
			{
				convert(dynamic_cast<PPTX::Logic::Blur*>(oox_unknown));
			}break;
			case OOX::et_a_fillOverlay:
			{
				convert(dynamic_cast<PPTX::Logic::FillOverlay*>(oox_unknown));
			}break;
			case OOX::et_a_glow:
			{
				convert(dynamic_cast<PPTX::Logic::Glow*>(oox_unknown));
			}break;
			case OOX::et_a_innerShdw:
			{
				convert(dynamic_cast<PPTX::Logic::InnerShdw*>(oox_unknown));
			}break;
			case OOX::et_a_outerShdw:
			{
				convert(dynamic_cast<PPTX::Logic::OuterShdw*>(oox_unknown));
			}break;
			case OOX::et_a_reflection:
			{
				convert(dynamic_cast<PPTX::Logic::Reflection*>(oox_unknown));
			}break;
			case OOX::et_a_softEdge:
			{
				convert(dynamic_cast<PPTX::Logic::SoftEdge*>(oox_unknown));
			}break;
			case OOX::et_a_grayscl:
			{
				convert(dynamic_cast<PPTX::Logic::Grayscl*>(oox_unknown));
			}break;
			case OOX::et_a_duotone:
			{
				convert(dynamic_cast<PPTX::Logic::Duotone*>(oox_unknown));
			}break;
			case OOX::et_a_effectDag:
			{
				convert(dynamic_cast<PPTX::Logic::EffectDag*>(oox_unknown));
			}break;
//---------------------------------------
			case OOX::et_v_shapetype:
			{
				convert(dynamic_cast<OOX::Vml::CShapeType*>(oox_unknown));
			}break;
			case OOX::et_v_shape:
			{
				convert(dynamic_cast<OOX::Vml::CShape*>(oox_unknown), NULL);
			}break;
			case OOX::et_v_oval:
			{
				convert(dynamic_cast<OOX::Vml::COval*>(oox_unknown));
			}break;
			case OOX::et_v_rect:
			{
				convert(dynamic_cast<OOX::Vml::CRect*>(oox_unknown));
			}break;
			case OOX::et_v_roundrect:
			{
				convert(dynamic_cast<OOX::Vml::CRoundRect*>(oox_unknown));
			}break;
			case OOX::et_v_line:
			{
				convert(dynamic_cast<OOX::Vml::CLine*>(oox_unknown));
			}break;
			case OOX::et_v_arc:
			{
				convert(dynamic_cast<OOX::Vml::CArc*>(oox_unknown));
			}break;
			case OOX::et_v_curve:
			{
				convert(dynamic_cast<OOX::Vml::CCurve*>(oox_unknown));
			}break;
			case OOX::et_v_group:
			{
				convert(dynamic_cast<OOX::Vml::CGroup*>(oox_unknown));
			}break;
			case OOX::et_v_polyline:
			{
				convert(dynamic_cast<OOX::Vml::CPolyLine*>(oox_unknown));
			}break;
			case OOX::et_v_imagedata:
			{
				convert(dynamic_cast<OOX::Vml::CImageData*>(oox_unknown));
			}break;
			case OOX::et_v_textbox:
			{
				convert(dynamic_cast<OOX::Vml::CTextbox*>(oox_unknown));
			}break;
			case OOX::et_v_background:
			{
				convert(dynamic_cast<OOX::Vml::CBackground*>(oox_unknown));
			}break;
			case OOX::et_v_textpath:
			{
				convert(dynamic_cast<OOX::Vml::CTextPath*>(oox_unknown));
			}break;	
			case OOX::et_v_fill:
			{
				convert(dynamic_cast<OOX::Vml::CFill*>(oox_unknown));
			}break;
			case OOX::et_v_stroke:
			{
				convert(dynamic_cast<OOX::Vml::CStroke*>(oox_unknown));
			}break;
			case OOX::et_v_shadow:
			{
				convert(dynamic_cast<OOX::Vml::CShadow*>(oox_unknown));
			}break;
			case OOX::et_v_image:
			{
				convert(dynamic_cast<OOX::Vml::CImage*>(oox_unknown));
			}break;
			case OOX::et_wd_wrap:
			{
				convert(dynamic_cast<OOX::VmlWord::CWrap*>(oox_unknown));
			}break;
//----------------------------------
			case OOX::et_a_extLst:
			{
				convert(dynamic_cast<OOX::Drawing::COfficeArtExtensionList*>(oox_unknown));
			}break;
			case OOX::et_a_ext:
			{
				convert(dynamic_cast<OOX::Drawing::COfficeArtExtension*>(oox_unknown));
			}break;
			// "ненужные" элементы
			case OOX::et_w_softHyphen:
			case OOX::et_w_proofErr:
			case OOX::et_w_proofState:
			{
				//бяка
			}break;
			//--Math
			case OOX::et_m_oMath:
			{
				convert(dynamic_cast<OOX::Logic::COMath*>(oox_unknown));
			}break;
			case OOX::et_m_mathPr:
			{
				convert(dynamic_cast<OOX::Logic::CMathPr*>(oox_unknown));
			}break;
			case OOX::et_m_oMathPara:
			{
				convert(dynamic_cast<OOX::Logic::COMathPara*>(oox_unknown));
			}break;
			case OOX::et_m_oMathParaPr:
			{
				convert(dynamic_cast<OOX::Logic::COMathParaPr*>(oox_unknown));
			}break;
			case OOX::et_m_ctrlPr:
			{
				convert(dynamic_cast<OOX::Logic::CCtrlPr*>(oox_unknown));
			}break;
			case OOX::et_m_acc:
			{
				convert(dynamic_cast<OOX::Logic::CAcc*>(oox_unknown));
			}break;
			case OOX::et_m_accPr:
			{
				convert(dynamic_cast<OOX::Logic::CAccPr*>(oox_unknown));
			}break;
			case OOX::et_m_argPr:
			{
				convert(dynamic_cast<OOX::Logic::CArgPr*>(oox_unknown));
			}break;
			case OOX::et_m_bar:
			{
				convert(dynamic_cast<OOX::Logic::CBar*>(oox_unknown));
			}break;
			case OOX::et_m_barPr:
			{
				convert(dynamic_cast<OOX::Logic::CBarPr*>(oox_unknown));
			}break;
			case OOX::et_m_borderBox:
			{
				convert(dynamic_cast<OOX::Logic::CBorderBox*>(oox_unknown));
			}break;
			case OOX::et_m_borderBoxPr:
			{
				convert(dynamic_cast<OOX::Logic::CBorderBoxPr*>(oox_unknown));
			}break;
			case OOX::et_m_box:
			{
				convert(dynamic_cast<OOX::Logic::CBox*>(oox_unknown));
			}break;
			case OOX::et_m_boxPr:
			{
				convert(dynamic_cast<OOX::Logic::CBoxPr*>(oox_unknown));
			}break;
			case OOX::et_m_brk:
			{
				convert(dynamic_cast<OOX::Logic::CBrk*>(oox_unknown));
			}break;
			case OOX::et_m_d:
			{
				convert(dynamic_cast<OOX::Logic::CDelimiter*>(oox_unknown));
			}break;
			case OOX::et_m_dPr:
			{
				convert(dynamic_cast<OOX::Logic::CDelimiterPr*>(oox_unknown));
			}break;
			case OOX::et_m_eqArr:
			{
				convert(dynamic_cast<OOX::Logic::CEqArr *>(oox_unknown));
			}break;
			case OOX::et_m_eqArrPr:
			{
				convert(dynamic_cast<OOX::Logic::CEqArrPr *>(oox_unknown));
			}break;
			case OOX::et_m_f:
			{
				convert(dynamic_cast<OOX::Logic::CFraction*>(oox_unknown));
			}break;
			case OOX::et_m_fPr:
			{
				convert(dynamic_cast<OOX::Logic::CFPr*>(oox_unknown));
			}break;
			case OOX::et_m_func:
			{
				convert(dynamic_cast<OOX::Logic::CFunc*>(oox_unknown));
			}break;
			case OOX::et_m_funcPr:
			{
				convert(dynamic_cast<OOX::Logic::CFuncPr*>(oox_unknown));
			}break;
			case OOX::et_m_groupChr:
			{
				convert(dynamic_cast<OOX::Logic::CGroupChr*>(oox_unknown));
			}break;
			case OOX::et_m_groupChrPr:
			{
				convert(dynamic_cast<OOX::Logic::CGroupChrPr*>(oox_unknown));
			}break;
			case OOX::et_m_limLow:
			{
				convert(dynamic_cast<OOX::Logic::CLimLow*>(oox_unknown));
			}break;
			case OOX::et_m_limLowPr:
			{
				convert(dynamic_cast<OOX::Logic::CLimLowPr*>(oox_unknown));
			}break;
			case OOX::et_m_limUpp:
			{
				convert(dynamic_cast<OOX::Logic::CLimUpp*>(oox_unknown));
			}break;
			case OOX::et_m_limUppPr:
			{
				convert(dynamic_cast<OOX::Logic::CLimUppPr*>(oox_unknown));
			}break;
			case OOX::et_m_mathFont:
			{
				convert(dynamic_cast<OOX::Logic::CMathFont*>(oox_unknown));
			}break;
			case OOX::et_m_m:
			{
				convert(dynamic_cast<OOX::Logic::CMatrix*>(oox_unknown));
			}break;
			case OOX::et_m_mc:
			{
				convert(dynamic_cast<OOX::Logic::CMc*>(oox_unknown));
			}break;
			case OOX::et_m_mcPr:
			{
				convert(dynamic_cast<OOX::Logic::CMcPr*>(oox_unknown));
			}break;
			case OOX::et_m_mcs:
			{
				convert(dynamic_cast<OOX::Logic::CMcs*>(oox_unknown));
			}break;
			case OOX::et_m_mPr:
			{
				convert(dynamic_cast<OOX::Logic::CMPr*>(oox_unknown));
			}break;
			case OOX::et_m_mr:
			{
				convert(dynamic_cast<OOX::Logic::CMr*>(oox_unknown));
			}break;
			case OOX::et_m_r:
			{
				convert(dynamic_cast<OOX::Logic::CMRun*>(oox_unknown));
			}break;
			case OOX::et_m_t:
			{
				convert(dynamic_cast<OOX::Logic::CMText*>(oox_unknown));
			}break;
			case OOX::et_m_nary:
			{
				convert(dynamic_cast<OOX::Logic::CNary*>(oox_unknown));
			}break;
			case OOX::et_m_naryPr:
			{
				convert(dynamic_cast<OOX::Logic::CNaryPr*>(oox_unknown));
			}break;
			case OOX::et_m_phant:
			{
				convert(dynamic_cast<OOX::Logic::CPhant*>(oox_unknown));
			}break;
			case OOX::et_m_phantPr:
			{
				convert(dynamic_cast<OOX::Logic::CPhantPr*>(oox_unknown));
			}break;
			case OOX::et_m_rad:
			{
				convert(dynamic_cast<OOX::Logic::CRad*>(oox_unknown));
			}break;
			case OOX::et_m_radPr:
			{
				convert(dynamic_cast<OOX::Logic::CRadPr*>(oox_unknown));
			}break;
			case OOX::et_m_sPre:
			{
				convert(dynamic_cast<OOX::Logic::CSPre*>(oox_unknown));
			}break;
			case OOX::et_m_sPrePr:
			{
				convert(dynamic_cast<OOX::Logic::CSPrePr*>(oox_unknown));
			}break;
			case OOX::et_m_sSub:
			{
				convert(dynamic_cast<OOX::Logic::CSSub*>(oox_unknown));
			}break;
			case OOX::et_m_sSubPr:
			{
				convert(dynamic_cast<OOX::Logic::CSSubPr*>(oox_unknown));
			}break;
			case OOX::et_m_sSubSup:
			{
				convert(dynamic_cast<OOX::Logic::CSSubSup*>(oox_unknown));
			}break;
			case OOX::et_m_sSubSupPr:
			{
				convert(dynamic_cast<OOX::Logic::CSSubSupPr*>(oox_unknown));
			}break;
			case OOX::et_m_sSup:
			{
				convert(dynamic_cast<OOX::Logic::CSSup*>(oox_unknown));
			}break;
			case OOX::et_m_sSupPr:
			{
				convert(dynamic_cast<OOX::Logic::CSSupPr*>(oox_unknown));
			}break;
			case OOX::et_m_e:
			{
				convert(dynamic_cast<OOX::Logic::CElement*>(oox_unknown));
			}break;
			case OOX::et_w_rPr:
			{
				convert(dynamic_cast<OOX::Logic::CRunProperty*>(oox_unknown));
			}
			break;
			default:
			{
                _CP_LOG << L"[warning] :  no convert element(" << oox_unknown->getType() << L")\n";
			}
		}
	}catch(...)
	{
        _CP_LOG << L"[error] :  no convert element(" << (oox_unknown ? oox_unknown->getType() : -1 ) << L")\n";
	}
}
std::wstring OoxConverter::find_link_by (smart_ptr<OOX::File> & oFile, int type, bool & bExternal)
{
	bExternal = false;

	if (!oFile.IsInit()) return L"";
	
    std::wstring ref;
	if (type == 1 && OOX::FileTypes::Image == oFile->type())
	{
		OOX::Image* pImage = dynamic_cast<OOX::Image*>(oFile.GetPointer());

		if (pImage)
		{
			ref = pImage->filename().GetPath();
			bExternal = pImage->IsExternal();
		}
	}
	if (type == 2 && OOX::FileTypes::HyperLink == oFile->type())
	{
		OOX::HyperLink* pHyperlink = dynamic_cast<OOX::HyperLink*>(oFile.GetPointer());
		
		if (pHyperlink && pHyperlink->bHyperlink)
		{
			ref = pHyperlink->Uri().GetPath();
			bExternal = true;
		}
	}
	if (type == 3)
	{
		OOX::Media* pMedia = dynamic_cast<OOX::Media*>(oFile.GetPointer());

		if (pMedia)
		{
			ref = pMedia->filename().GetPath();
			bExternal = pMedia->IsExternal();
		}
	}
	if (type == 4)
	{
		OOX::OleObject* pOleObject = dynamic_cast<OOX::OleObject*>(oFile.GetPointer());

		if (pOleObject)
		{
			ref = pOleObject->filename().GetPath();
			bExternal = dynamic_cast<OOX::Media*>(pOleObject)->IsExternal();
		}
	}
	return ref;
}

bool OoxConverter::convert(std::wstring sSchemeColor, DWORD & argb)
{
	PPTX::Theme * theme= oox_theme();
	if (!theme)return false;

	std::map<std::wstring, PPTX::Logic::UniColor>::iterator pFind = theme->themeElements.clrScheme.Scheme.find(sSchemeColor);

	if (pFind != theme->themeElements.clrScheme.Scheme.end())
	{
		PPTX::Logic::UniColor & color = pFind->second;
		
		argb = color.GetARGB(); 

		return true;
	}
	return false;
}

void OoxConverter::convert(double oox_font_size,  _CP_OPT(odf_types::font_size) & odf_font_size)
{
	 _CP_OPT(odf_types::length) odf_length;

	 odf_length = odf_types::length(oox_font_size, odf_types::length::pt);
	 
	 if (odf_length)
		 odf_font_size = odf_types::font_size(odf_length.get());
}
void OoxConverter::convert(OOX::JsaProject *jsaProject)
{
	if (!jsaProject) return;

	std::string content;
	NSFile::CFileBinary file;
	
	file.OpenFile(jsaProject->filename().GetPath());
	
	DWORD size = file.GetFileSize();
	content.resize(size);

	file.ReadFile((BYTE*)content.c_str(), size, size);
	file.CloseFile();
	
	content[size] = 0;

	output_document->add_binary(L"jsaProject.bin", content);
}
}