/*
 * (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 "odfcontext.h"

namespace cpdoccore {

	using namespace odf_types;

	std::string DecodeBase64(const std::wstring& value1)
	{
		int nLength = 0;
		unsigned char* pData = NULL;
		std::string result;

		std::string value(value1.begin(), value1.end());

		NSFile::CBase64Converter::Decode(value.c_str(), value.length(), pData, nLength);
		if (pData)
		{
			result = std::string((char*)pData, nLength);
			delete[]pData; pData = NULL;
		}
		return result;
	}
	namespace odf_reader {

		style_instance::style_instance(
			styles_container* Container,
			const std::wstring& Name,
			const std::wstring& DisplayName,
			style_family::type	Type,
			style_content* Content,
			bool IsAutomatic,
			bool IsDefault,
			const std::wstring& ParentStyleName,
			const std::wstring& NextStyleName,
			const std::wstring& DataStyleName,
			const std::wstring& PercentageDataStyleName,
			const std::wstring& StyleClass,
			_CP_OPT(std::wstring)	ListStyleName,
			_CP_OPT(int)			ListLevel,
			_CP_OPT(int)			OutlineLevel
		) :
			container_(Container),
			name_(Name),
			display_name_(DisplayName),
			style_type_(Type),
			content_(Content),
			is_automatic_(IsAutomatic),
			is_default_(IsDefault),
			next_name_(NextStyleName),
			style_class_(StyleClass),
			next_(Container->style_by_name(NextStyleName, style_type_, false)),
			data_style_name_(DataStyleName),
			percentage_data_style_name_(PercentageDataStyleName),
			list_style_name_(ListStyleName),
			list_level_(ListLevel),
			outline_level_(OutlineLevel)
		{
			parent_name_ = ParentStyleName;
			if (parent_name_ == L"Textformatvorlage")//http://ask.libreoffice.org/en/question/35136/textformatvorlage-style/
			{
				parent_name_ = L"Standard";
			}
			parent_ = Container->style_by_name(parent_name_, style_type_, false);
		}

		style_instance* styles_container::hyperlink_style()
		{
			if (hyperlink_style_pos_ > 0 && hyperlink_style_pos_ < (int)instances_.size())
				return instances_[hyperlink_style_pos_].get();
			else
				return NULL;
		}

		void styles_container::add_style(const std::wstring& Name,
			const std::wstring& DisplayName,
			style_content* Content,
			bool IsAutomatic,
			bool IsDefault,
			const std::wstring& ParentStyleName_,
			const std::wstring& NextStyleName,
			const std::wstring& DataStyleName,
			const std::wstring& PercentageDataStyleName,
			const std::wstring& StyleClass,
			_CP_OPT(std::wstring)	ListStyleName,
			_CP_OPT(int)			ListLevel,
			_CP_OPT(int)			OutlineLevel)
		{
			std::wstring ParentStyleName = ParentStyleName_;

			style_family::type Type = Content ? Content->style_family_.get_type() : style_family::None;

			if (Name == ParentStyleName)
			{
				ParentStyleName = L"";//иначе в коде возможно зацикливание.
			}
			style_instance_ptr newStyle = style_instance_ptr(new style_instance(this, Name, DisplayName, Type, Content, IsAutomatic, IsDefault,
				ParentStyleName, NextStyleName, DataStyleName, PercentageDataStyleName, StyleClass, ListStyleName, ListLevel, OutlineLevel));

			instances_.push_back(newStyle);
			int pos = static_cast<int>(instances_.size() - 1);

			if (!Name.empty())
			{
				std::wstring n = Name + L":" + boost::lexical_cast<std::wstring>(style_family(Type));
				map_[n] = pos;

				// TODO: как правильно??
				std::wstring lName = XmlUtils::GetLower(Name);
				//if ( boost::algorithm::contains(lName, L"internet_20_link") )
				if (lName == L"internet_20_link")///???????????????
					hyperlink_style_pos_ = pos;
			}

			if (!DisplayName.empty())
			{
				std::wstring n = DisplayName + L":" + boost::lexical_cast<std::wstring>(style_family(Type));
				map2_[n] = pos;
			}

			if (IsDefault)
				default_map_[Type] = pos;

		}

		const std::wstring& style_instance::name() const
		{
			return name_;
		}
		const std::wstring& style_instance::display_name() const
		{
			return display_name_;
		}
		style_family::type style_instance::type() const
		{
			return style_type_;
		}

		style_content* style_instance::content() const
		{
			return content_;
		}

		style_instance* style_instance::parent() const
		{
			if (parent_)
				return parent_;
			else if (container_)
				parent_ = container_->style_by_name(parent_name_, type(), false);

			return parent_;
		}

		const std::wstring& style_instance::parent_name() const
		{
			return parent_name_;
		}

		style_instance* style_instance::next() const
		{
			if (next_)
				return next_;
			else if (container_ && next_name_.empty() == false)
				next_ = container_->style_by_name(next_name_, type(), false);

			return next_;
		}

		const std::wstring& style_instance::next_name() const
		{
			return next_name_;
		}

		bool style_instance::is_automatic() const
		{
			return is_automatic_;
		}

		bool style_instance::is_default() const
		{
			return is_default_;
		}
		const std::wstring& style_instance::percentage_data_style_name() const
		{
			return percentage_data_style_name_;
		}
		const std::wstring& style_instance::data_style_name() const
		{
			return data_style_name_;
		}
		_CP_OPT(std::wstring) style_instance::list_style_name() const
		{
			return list_style_name_;
		}
		const std::wstring& style_instance::style_class() const
		{
			return style_class_;
		}
		_CP_OPT(int) style_instance::list_level() const
		{
			return list_level_;
		}
		_CP_OPT(int) style_instance::outline_level() const
		{
			return outline_level_;
		}

		style_instance* styles_container::style_by_name(const std::wstring& Name, style_family::type Type, bool object_in_styles) const
		{
			std::wstring n = L"";
			if (object_in_styles) n = L"common:";
			n = n + Name + L":" + boost::lexical_cast<std::wstring>(style_family(Type));

			map_wstring_int_t::const_iterator res = map_.find(n);

			if (res != map_.end())
			{
				int index = res->second;
				return instances_[index].get();
			}
			else if (object_in_styles)
			{
				//try automatic
				n = Name + L":" + boost::lexical_cast<std::wstring>(style_family(Type));

				map_wstring_int_t::const_iterator res = map_.find(n);

				if (res != map_.end())
				{
					int index = res->second;
					return instances_[index].get();
				}
			}
			return NULL;
		}
		style_instance* styles_container::style_by_display_name(const std::wstring& Name, style_family::type Type, bool object_in_styles) const
		{
			std::wstring n = L"";
			if (object_in_styles) n = L"common:";
			n = n + Name + L":" + boost::lexical_cast<std::wstring>(style_family(Type));

			map_wstring_int_t::const_iterator res = map2_.find(n);

			if (res != map2_.end())
			{
				int index = res->second;
				return instances_[index].get();
			}
			else
				return NULL;
		}
		void styles_container::add_master_page_name(const std::wstring& StyleName, const std::wstring& MasterPageName)
		{
			master_page_name_[StyleName] = MasterPageName;
		}

		std::pair<int, std::wstring> presentation_layouts_instance::add_or_find(const std::wstring& layout_name, const std::wstring& master_name)
		{
			std::map<std::wstring, size_t>::iterator pFind = mapUsed.find(master_name + layout_name);

			if (pFind == mapUsed.end())
			{
				presentation_layouts_instance::_layout item;
				item.layout_name = layout_name;
				item.master_name = master_name;
				item.Id = content.size() + 1;
				item.rId = std::wstring(L"lrId") + std::to_wstring(item.Id);

				content.push_back(item);

				mapUsed.insert(std::make_pair(master_name + layout_name, content.size() - 1));
				return std::pair<int, std::wstring>(item.Id, item.rId);
			}
			else
			{
				return std::pair<int, std::wstring>(content[pFind->second].Id, content[pFind->second].rId);
			}
		}

		std::pair<int, std::wstring> presentation_masters_instance::add_or_find(const std::wstring& master_name)
		{
			std::map<std::wstring, size_t>::iterator pFind = mapUsed.find(master_name);

			if (pFind == mapUsed.end())
			{
				presentation_masters_instance::_master item;
				item.master_name = master_name;
				item.Id = content.size() + 1;
				item.rId = std::wstring(L"smId") + std::to_wstring(item.Id);

				content.push_back(item);

				mapUsed.insert(std::make_pair(master_name, content.size() - 1));
				return std::pair<int, std::wstring>(item.Id, item.rId);
			}
			else
			{
				return std::pair<int, std::wstring>(content[pFind->second].Id, content[pFind->second].rId);
			}
		}

		void presentation_masters_instance::add_layout_to(const std::wstring& master_name, presentation_layouts_instance::_layout& layout)
		{
			std::map<std::wstring, size_t>::iterator pFind = mapUsed.find(master_name);

			if (pFind != mapUsed.end())
			{
				content[pFind->second].layouts.push_back(layout);

			}
		}

		const _CP_OPT(std::wstring) styles_container::master_page_name_by_name(const std::wstring& StyleName) const
		{
			_CP_OPT(std::wstring) master_page;

			map_wstring_wstring::const_iterator res = master_page_name_.find(StyleName);
			if (res != master_page_name_.end())
				master_page = res->second;
			return master_page;
		}

		style_instance* styles_container::style_default_by_type(style_family::type Type) const
		{
			map_style_family_int::const_iterator res = default_map_.find(Type);
			if (res != default_map_.end())
				return instances_[res->second].get();
			else
				return NULL;
		}

		page_layout_instance::page_layout_instance(const style_page_layout* StylePageLayout) : style_page_layout_(StylePageLayout)
		{
		}

		const std::wstring& page_layout_instance::name() const
		{
			return style_page_layout_->style_name_;
		}

		style_page_layout_properties* page_layout_instance::properties() const
		{
			return dynamic_cast<style_page_layout_properties*>(style_page_layout_->style_page_layout_properties_.get());
		}

		void page_layout_instance::xlsx_serialize(std::wostream& strm, oox::xlsx_conversion_context& Context)
		{
			const style_header_style* headerStyle = dynamic_cast<style_header_style*>(style_page_layout_->style_header_style_.get());
			const style_footer_style* footerStyle = dynamic_cast<style_footer_style*>(style_page_layout_->style_footer_style_.get());

			style_header_footer_properties* headerProp = headerStyle ? dynamic_cast<style_header_footer_properties*>(headerStyle->style_header_footer_properties_.get()) : NULL;
			style_header_footer_properties* footerProp = footerStyle ? dynamic_cast<style_header_footer_properties*>(footerStyle->style_header_footer_properties_.get()) : NULL;

			if (headerProp)
			{
				const style_header_footer_properties_attlist& attr = headerProp->style_header_footer_properties_attlist_;
				_CP_OPT(double) header;

				if (attr.fo_min_height_)	header = attr.fo_min_height_->get_value_unit(length::inch);
				else if (attr.svg_height_)	header = attr.svg_height_->get_value_unit(length::inch);

				Context.get_table_context().set_header_page(header);
			}

			if (footerProp)
			{
				const style_header_footer_properties_attlist& attr = footerProp->style_header_footer_properties_attlist_;
				_CP_OPT(double) footer;

				if (attr.fo_min_height_)	footer = attr.fo_min_height_->get_value_unit(length::inch);
				else if (attr.svg_height_)	footer = attr.svg_height_->get_value_unit(length::inch);

				Context.get_table_context().set_footer_page(footer);
			}

			style_page_layout_properties* props = properties();
			if (props)
				props->xlsx_serialize(strm, Context);
		}

		void page_layout_instance::docx_serialize(std::wostream& strm, oox::docx_conversion_context& Context)
		{
			const style_header_style* headerStyle = dynamic_cast<style_header_style*>(style_page_layout_->style_header_style_.get());
			const style_footer_style* footerStyle = dynamic_cast<style_footer_style*>(style_page_layout_->style_footer_style_.get());

			style_header_footer_properties* headerProp = headerStyle ? dynamic_cast<style_header_footer_properties*>(headerStyle->style_header_footer_properties_.get()) : NULL;
			style_header_footer_properties* footerProp = footerStyle ? dynamic_cast<style_header_footer_properties*>(footerStyle->style_header_footer_properties_.get()) : NULL;

			Context.get_header_footer_context().reset();

			if (headerProp)
			{
				const style_header_footer_properties_attlist& attr = headerProp->style_header_footer_properties_attlist_;
				_CP_OPT(length) top = attr.fo_min_height_ ? attr.fo_min_height_ : attr.svg_height_;
				Context.get_header_footer_context().set_header(top);
			}

			if (footerProp)
			{
				const style_header_footer_properties_attlist& attr = footerProp->style_header_footer_properties_attlist_;
				_CP_OPT(length) bottom = attr.fo_min_height_ ? attr.fo_min_height_ : attr.svg_height_;
				Context.get_header_footer_context().set_footer(bottom);
			}

			if (style_page_layout_->style_page_usage_.get_type() == page_usage::Mirrored)
			{
				Context.set_settings_property(odf_reader::_property(L"mirrorMargins", true));
			}

			style_page_layout_properties* props = properties();
			if (props)
				props->docx_serialize(strm, Context);
		}
		void page_layout_instance::pptx_serialize(std::wostream& strm, oox::pptx_conversion_context& Context)
		{
			style_page_layout_properties* props = properties();
			if (props)
				props->pptx_serialize(strm, Context);
		}

		void page_layout_container::add_page_layout(const style_page_layout* StylePageLayout)
		{
			page_layout_instance_ptr instance = page_layout_instance_ptr(new page_layout_instance(StylePageLayout));
			instances_.push_back(instance);
			const int pos = static_cast<int>(instances_.size() - 1);

			page_layout_names_[instance->name()] = pos;

		}

		void page_layout_container::add_master_page(const std::wstring& StyleName, const std::wstring& PageLayoutName, style_master_page* MasterPage)
		{
			master_page_names_array_.push_back(StyleName);
			master_page_names_[StyleName] = PageLayoutName;

			master_pages_.push_back(MasterPage);
			const int pos = static_cast<int>(master_pages_.size() - 1);
			master_page_names_2_[StyleName] = pos;
		}

		void page_layout_container::add_presentation_page_layout(const std::wstring& StyleName, style_presentation_page_layout* StylePageLayout)
		{
			presentation_page_layouts_.push_back(StylePageLayout);

			const int pos = static_cast<int>(presentation_page_layouts_.size() - 1);
			presentation_page_layout_names_[StyleName] = pos;
		}


		const std::wstring page_layout_container::page_layout_name_by_style(const std::wstring& StyleName) const
		{
			if (master_page_names_.count(StyleName) > 0)
				return master_page_names_.at(StyleName);
			return L"";
		}

		const page_layout_instance* page_layout_container::page_layout_by_style(const std::wstring& StyleName) const
		{
			if (master_page_names_.count(StyleName) > 0)
				if (page_layout_names_.count(master_page_names_.at(StyleName)))
					return instances_[page_layout_names_.at(master_page_names_.at(StyleName))].get();
			return NULL;
		}

		page_layout_instance* page_layout_container::page_layout_by_name(const std::wstring& Name) const
		{
			if (page_layout_names_.count(Name))
				return instances_[page_layout_names_.at(Name)].get();
			return NULL;
		}

		const page_layout_instance* page_layout_container::page_layout_first() const
		{
			if (master_page_names_array_.empty())
				return NULL;

			return page_layout_by_style(master_page_names_array_[0]);
		}
		bool page_layout_container::compare_page_properties(const std::wstring& master1, const std::wstring& master2)
		{
			const page_layout_instance* page_layout1 = page_layout_by_style(master1);
			const page_layout_instance* page_layout2 = page_layout_by_style(master2);

			if (!page_layout1 || !page_layout2) return true;
			if (!page_layout1->style_page_layout_ || !page_layout1->style_page_layout_) return true;

			style_page_layout_properties* props1 = dynamic_cast<style_page_layout_properties*>(page_layout1->style_page_layout_->style_page_layout_properties_.get());
			style_page_layout_properties* props2 = dynamic_cast<style_page_layout_properties*>(page_layout2->style_page_layout_->style_page_layout_properties_.get());

			if (!props1 || !props2) return true;

			if (props1 == props2) return true;

			return props1->attlist_.compare(props2->attlist_);
		}

		style_presentation_page_layout* page_layout_container::presentation_page_layout_by_name(const std::wstring& Name)
		{
			style_presentation_page_layout* res = NULL;

			if (presentation_page_layout_names_.count(Name))
			{
				int ind = presentation_page_layout_names_.at(Name);
				res = presentation_page_layouts_[ind];
			}

			return res;
		}
		style_master_page* page_layout_container::master_page_by_name(const std::wstring& Name)
		{
			style_master_page* res = NULL;

			if (master_page_names_2_.count(Name))
				res = master_pages_[master_page_names_2_.at(Name)];

			return res;
		}

		font_instance::font_instance(const std::wstring& StyleName,
			const std::wstring& Name,
			const std::wstring& Charset,
			const std::wstring& Family,
			const std::wstring& Pitch,
			const std::wstring& AltName) : style_name_(StyleName), name_(Name), charset_(Charset), family_(Family), pitch_(Pitch), alt_name_(AltName)
		{}

		const std::wstring& font_instance::style_name() const
		{
			return style_name_;
		}

		const std::wstring& font_instance::name() const
		{
			return name_;
		}

		const std::wstring& font_instance::charset() const
		{
			return charset_;
		}

		const std::wstring& font_instance::family() const
		{
			return family_;
		}

		const std::wstring& font_instance::pitch() const
		{
			return pitch_;
		}

		const std::wstring& font_instance::alt_name() const
		{
			return alt_name_;
		}

		font_instance* fonts_container::font_by_style_name(const std::wstring& StyleName)
		{
			if (font_style_names_.count(StyleName) > 0)
				return instances_[font_style_names_.at(StyleName)].get();
			return NULL;
		}

		font_instance* fonts_container::font_by_name(const std::wstring& Name)
		{
			if (font_names_.count(Name) > 0)
				return instances_[font_names_.at(Name)].get();
			return NULL;
		}

		void fonts_container::add_font(font_instance_ptr FontInstance)
		{
			instances_.push_back(FontInstance);
			if (FontInstance)
			{
				font_style_names_[FontInstance->style_name()] = static_cast<int>(instances_.size() - 1);
				font_names_[FontInstance->name()] = static_cast<int>(instances_.size() - 1);
			}
		}

		void list_style_container::add_list_style(text_list_style* textListStyle)
		{
			if (!textListStyle) return;

			instances_.push_back(list_style_instance_ptr(new list_style_instance(textListStyle)));
			list_style_names_[textListStyle->attr_.style_name_] = static_cast<int>(instances_.size() - 1);
		}

		void list_style_container::add_list_style(text_list_style* textListStyle, const std::wstring& NewName)
		{
			if (!textListStyle) return;

			instances_.push_back(list_style_instance_ptr(new list_style_instance(textListStyle, NewName)));
			list_style_names_[NewName] = static_cast<int>(instances_.size() - 1);
		}
		void list_style_container::add_outline_style(text_outline_style* textOutlineStyle)
		{
			if (!textOutlineStyle) return;

			outline_ = textOutlineStyle;
		}
		text_list_style* list_style_container::list_style_by_name(const std::wstring& Name)
		{
			if (list_style_names_.count(Name) > 0)
				return instances_[list_style_names_.at(Name)]->get_text_list_style();
			return NULL;
		}

		text_outline_style* list_style_container::outline_style()
		{
			return outline_;
		}
		int list_style_container::id_outline()
		{
			return instances_.size() + 1;
		}

		int list_style_container::id_by_name(const std::wstring& Name)
		{
			if (list_style_names_.count(Name) > 0)
				return list_style_names_.at(Name) + 1;
			else
				return 0;
		}
		const text_notes_configuration* notes_configuration::getConfiguration(odf_types::noteclass::type noteType) const
		{
			if (type_to_name_.count(noteType))
				return type_to_name_.at(noteType);
			else
				return NULL;
		}

		void notes_configuration::add(odf_types::noteclass::type noteType, const text_notes_configuration* conf)
		{
			type_to_name_[noteType] = conf;
		}

	}
}