#pragma once
#include "cpps/cpps.h"
#include "rapidxml_adapter.hpp"
#include "rapidxml_adapter_print.hpp"
#include <iostream>

namespace cpps
{
 class xml_attribute
 {
 friend class xml_node;
 public:
 xml_attribute()
 {
 attribute_ = std::make_shared<rapidxml_adapter::xml_attribute<char>>();
 }

 void create(cpps_value name, cpps_value value)
 {
 if (cpps_isstring(name))
 {
		 std::string* str = cpps_get_string(name);
 set_name(*str);
 }
 if (cpps_isstring(value))
 {
		 std::string* str = cpps_get_string(value);
 set_value(*str);
 }
 }

 std::string name()
 {
 return attribute_->name();
 }

 std::string value()
 {
 return attribute_->value();
 }

 void set_name(std::string name)
 {
 attribute_->name(name);
 }

 void set_value(std::string value)
 {
 attribute_->value(value);
 }

 private:
 std::shared_ptr<rapidxml_adapter::xml_attribute<char>> attribute_;
 };

 class xml_node
 {
 public:
 xml_node()
 {
 node_ = std::make_shared<rapidxml_adapter::xml_node<char>>(rapidxml::node_element);
 }

 void create(cpps_value name, cpps_value value, cpps_value type_name)
 {
 if (cpps_isstring(name))
 {
		 std::string* str = cpps_get_string(name);
 set_name(*str);
 }
 if (cpps_isstring(value))
 {
		 std::string* str = cpps_get_string(value);
 set_value(*str);
 }
 if (cpps_isstring(type_name))
 {
		 std::string* str = cpps_get_string(value);
 set_type(*str);
 }
 }

 std::string to_string()
 {
 std::stringstream ss;
 ss << node_;
 return ss.str();
 }

 std::string type()
 {
 switch (node_->type())
 {
 case rapidxml::node_document:
 return "document";
 case rapidxml::node_element:
 return "element";
 case rapidxml::node_data:
 return "data";
 case rapidxml::node_cdata:
 return "cdata";
 case rapidxml::node_comment:
 return "comment";
 case rapidxml::node_declaration:
 return "declaration";
 case rapidxml::node_doctype:
 return "doctype";
 case rapidxml::node_pi:
 return "pi";
 default:
 return "none";
 }
 return "none";
 }

 std::string name() 
 {
 return node_->name(); 
 }

 std::string value()
 {
 return node_->value();
 }

 xml_node* first_node(C* c, cpps_value name)
 {
 std::string node_name;
 if (cpps_isstring(name))
 {
 node_name = *cpps_get_string(name);
 }
		 xml_node* ret = nullptr;
 std::shared_ptr<rapidxml_adapter::xml_node<char>> temp_node = node_->first_node(node_name);
 if (temp_node)
 {
		 cpps::object::create_with_classvar<xml_node>(c, &ret);
 ret->node_ = temp_node;
 }
 return ret;
 }

 xml_node* last_node(C* c, cpps_value name)
 {
 std::string node_name;
 if (cpps_isstring(name))
 {
 node_name = *cpps_get_string(name);
 }
		 xml_node* ret = nullptr;
 std::shared_ptr<rapidxml_adapter::xml_node<char>> temp_node = node_->last_node(node_name);
 if (temp_node)
 {
		 cpps::object::create_with_classvar<xml_node>(c, &ret);
 ret->node_ = temp_node;
 }
 return ret;
 }

 xml_node* previous_node(C* c, xml_node* current, cpps_value name)
 {
 if (current == nullptr)
 {
 return last_node(c, name);
 }
 if (current->node_->parent() != node_)
 {
 cpps::error(c, "xml_node::previous_node current node must be self's child");
 }
 std::string node_name;
 if (cpps_isstring(name))
 {
 node_name = *cpps_get_string(name);
 }
 xml_node* ret = nullptr;
 std::shared_ptr<rapidxml_adapter::xml_node<char>> temp_node = node_->previous_node(current->node_, node_name);
 if (temp_node)
 {
		 cpps::object::create_with_classvar<xml_node>(c, &ret);
 ret->node_ = temp_node;
 }
 return ret;
 }

 xml_node* next_node(C* c, xml_node* current, cpps_value name)
 {
 if (current == nullptr)
 {
 return first_node(c, name);
 }
 if (current->node_->parent() != node_)
 {
 cpps::error(c, "xml_node::next_node current node must be self's child");
 }
 std::string node_name;
 if (cpps_isstring(name))
 {
 node_name = *cpps_get_string(name);
 }
 xml_node* ret = nullptr;
 std::shared_ptr<rapidxml_adapter::xml_node<char>> temp_node = node_->next_node(current->node_, node_name);
 if (temp_node)
 {
		 cpps::object::create_with_classvar<xml_node>(c, &ret);
 ret->node_ = temp_node;
 }
 return ret;
 }

 xml_attribute* first_attribute(C* c, cpps_value name)
 {
 std::string attribute_name;
 if (cpps_isstring(name))
 {
 attribute_name = *cpps_get_string(name);
 }
 xml_attribute* ret = nullptr;
 std::shared_ptr<rapidxml_adapter::xml_attribute<char>> temp_attribute = node_->first_attribute(attribute_name);
 if (temp_attribute)
 {
		 cpps::object::create_with_classvar<xml_attribute>(c, &ret);
 ret->attribute_ = temp_attribute;
 }
 return ret;
 }

 xml_attribute* last_attribute(C* c, cpps_value name)
 {
 std::string attribute_name;
 if (cpps_isstring(name))
 {
 attribute_name = *cpps_get_string(name);
 }
 xml_attribute* ret = nullptr;
 std::shared_ptr<rapidxml_adapter::xml_attribute<char>> temp_attribute = node_->last_attribute(attribute_name);
 if (temp_attribute)
 {
		 cpps::object::create_with_classvar<xml_attribute>(c, &ret);
 ret->attribute_ = temp_attribute;
 }
 return ret;
 }

 xml_attribute* previous_attribute(C* c, xml_attribute* current, cpps_value name)
 {
 if (current == nullptr)
 {
 return last_attribute(c, name);
 }
 if (current->attribute_->parent() != node_)
 {
 cpps::error(c, "xml_node::previous_attribute current attribute must be self's child");
 }
 std::string attribute_name;
 if (cpps_isstring(name))
 {
 attribute_name = *cpps_get_string(name);
 }
 xml_attribute* ret = nullptr;
 std::shared_ptr<rapidxml_adapter::xml_attribute<char>> temp_attribute = node_->previous_attribute(current->attribute_, attribute_name);
 if (temp_attribute)
 {
		 cpps::object::create_with_classvar<xml_attribute>(c, &ret);
 ret->attribute_ = temp_attribute;
 }
 return ret;
 }

 xml_attribute* next_attribute(C* c, xml_attribute* current, cpps_value name)
 {
 if (current == nullptr)
 {
 return first_attribute(c, name);
 }
 if (current->attribute_->parent() != node_)
 {
 cpps::error(c, "xml_node::next_attribute current attribute must be self's child");
 }
 std::string attribute_name;
 if (cpps_isstring(name))
 {
 attribute_name = *cpps_get_string(name);
 }
 xml_attribute* ret = nullptr;
 std::shared_ptr<rapidxml_adapter::xml_attribute<char>> temp_attribute = node_->next_attribute(current->attribute_, attribute_name);
 if (temp_attribute)
 {
		 cpps::object::create_with_classvar<xml_attribute>(c, &ret);
 ret->attribute_ = temp_attribute;
 }
 return ret;
 }

 cpps_value children(C* c, cpps_value name)
 {
 std::string node_name;
 if (cpps_isstring(name))
 {
 node_name = *cpps_get_string(name);
 }
 return xml_node::children_to_cpps_value(c, node_name);
 }

 cpps_value attributes(C* c, cpps_value name)
 {
 std::string attribute_name;
 if (cpps_isstring(name))
 {
 attribute_name = *cpps_get_string(name);
 }
 return xml_node::attributes_to_cpps_value(c, attribute_name);
 }

 void set_type(std::string type_name)
 {
 static const std::map<std::string, rapidxml::node_type> node_type_by_name = {
 {"document", rapidxml::node_document},
 {"element", rapidxml::node_element},
 {"data", rapidxml::node_data},
 {"cdata", rapidxml::node_cdata},
 {"comment", rapidxml::node_comment},
 {"declaration", rapidxml::node_declaration},
 {"doctype", rapidxml::node_doctype},
 {"pi", rapidxml::node_pi},
 };
 auto iter = node_type_by_name.find(type_name);
 if (iter != node_type_by_name.end())
 {
 node_->type(iter->second);
 }
 }

 void set_name(std::string name)
 {
 node_->name(name);
 }

 void set_value(std::string value)
 {
 node_->value(value);
 }

 void prepend_node(C* c, xml_node* node)
 {
 if (node == nullptr)
 {
 cpps::error(c, "xml_node::prepend_node new node is nil");
 }
 if (node->node_->parent())
 {
 cpps::error(c, "xml_node::prepend_node new node must not have parent");
 }
 if (node->node_->type() == rapidxml::node_document)
 {
 cpps::error(c, "xml_node::prepend_node new node must not be a document node");
 }
 node_->prepend_node(node->node_);
 }

 void append_node(C* c, xml_node* node)
 {
 if (node == nullptr)
 {
 cpps::error(c, "xml_node::append_node new node is nil");
 }
 if (node->node_->parent())
 {
 cpps::error(c, "xml_node::append_node new node must not have parent");
 }
 if (node->node_->type() == rapidxml::node_document)
 {
 cpps::error(c, "xml_node::append_node new node must not be a document node");
 }
 node_->append_node(node->node_);
 }

 void insert_node(C* c, xml_node* where, xml_node* node)
 {
 if (where == nullptr)
 {
 append_node(c, node);
 }
 if (where->node_->parent() != node_)
 {
 cpps::error(c, "xml_node::insert_node where node must be self's child");
 }
 if (node == nullptr)
 {
 cpps::error(c, "xml_node::insert_node new node is nil");
 }
 if (node->node_->parent())
 {
 cpps::error(c, "xml_node::insert_node new node must not have parent");
 }
 if (node->node_->type() == rapidxml::node_document)
 {
 cpps::error(c, "xml_node::insert_node new node must not be a document node");
 }
 node_->insert_node(where->node_, node->node_);
 }

 void remove_first_node(C* c)
 {
 if (!node_->first_node())
 {
 cpps::error(c, "xml_node::remove_first_node has no child to remove");
 }
 node_->remove_first_node();
 }

 void remove_last_node(C* c)
 {
 if (!node_->first_node())
 {
 cpps::error(c, "xml_node::remove_last_node has no child to remove");
 }
 node_->remove_last_node();
 }

 void remove_node(C* c, xml_node* node)
 {
 if (node == nullptr)
 {
 cpps::error(c, "xml_node::remove_node node is nil");
 }
 if (node->node_->parent() != node_)
 {
 cpps::error(c, "xml_node::insert_node node must be self's child");
 }
 node_->remove_node(node->node_);
 }

 void remove_all_nodes()
 {
 node_->remove_all_nodes();
 }

 void prepend_attribute(C* c, xml_attribute* attribute)
 {
 if (attribute == nullptr)
 {
 cpps::error(c, "xml_node::prepend_attribute new attribute is nil");
 }
 if (attribute->attribute_->parent())
 {
 cpps::error(c, "xml_node::prepend_attribute new attribute must not have parent");
 }
 node_->prepend_attribute(attribute->attribute_);
 }

 void append_attribute(C* c, xml_attribute* attribute)
 {
 if (attribute == nullptr)
 {
 cpps::error(c, "xml_node::append_attribute new attribute is nil");
 }
 if (attribute->attribute_->parent())
 {
 cpps::error(c, "xml_node::append_attribute new attribute must not have parent");
 }
 node_->append_attribute(attribute->attribute_);
 }

 void insert_attribute(C* c, xml_attribute* where, xml_attribute* attribute)
 {
 if (where == nullptr)
 {
 append_attribute(c, attribute);
 }
 if (where->attribute_->parent() != node_)
 {
 cpps::error(c, "xml_node::insert_attribute where attribute must be self's child");
 }
 if (attribute == nullptr)
 {
 cpps::error(c, "xml_node::insert_attribute new attribute is nil");
 }
 if (attribute->attribute_->parent())
 {
 cpps::error(c, "xml_node::insert_attribute new attribute must not have parent");
 }
 node_->insert_attribute(where->attribute_, attribute->attribute_);
 }

 void remove_first_attribute(C* c)
 {
 if (!node_->first_attribute())
 {
 cpps::error(c, "xml_node::remove_first_attribute has no attribute to remove");
 }
 node_->remove_first_attribute();
 }

 void remove_last_attribute(C* c)
 {
 if (!node_->first_attribute())
 {
 cpps::error(c, "xml_node::remove_last_attribute has no attribute to remove");
 }
 node_->remove_last_attribute();
 }

 void remove_attribute(C* c, xml_attribute* attribute)
 {
 if (attribute == nullptr)
 {
 cpps::error(c, "xml_node::remove_attribute attribute is nil");
 }
 if (attribute->attribute_->parent() != node_)
 {
 cpps::error(c, "xml_node::remove_attribute attribute must be self's child");
 }
 node_->remove_attribute(attribute->attribute_);
 }

 void remove_all_attributes()
 {
 node_->remove_all_attributes();
 }
 private:
 cpps_value children_to_cpps_value(C* c, const std::string& name = std::string())
 {
 cpps_vector* ret_vec;
 cpps_value ret;
 newclass<cpps_vector>(c, &ret_vec,&ret);
 for(auto child : node_->children(name))
 {
 xml_node* ret_node;
 cpps_value node_value;
 newclass<xml_node>(c, &ret_node,&node_value);
 ret_node->node_ = child;
 ret_vec->push_back(node_value);
 }
 return ret;
 }

 cpps_value attributes_to_cpps_value(C* c, const std::string &name = std::string())
 {
 cpps_vector* ret_vec;
 cpps_value ret;
 newclass<cpps_vector>(c, &ret_vec,&ret);
 for(auto attr : node_->attributes(name))
 {
 xml_attribute* ret_attr;
 cpps_value attr_value;
 newclass<xml_attribute>(c, &ret_attr,&attr_value);
 ret_attr->attribute_ = attr;
 ret_vec->push_back(attr_value);
 }
 return ret;
 }
 protected:
 std::shared_ptr<rapidxml_adapter::xml_node<char>> node_;
 };

 class xml_document : public xml_node
 {
 public:
 xml_document()
 {
 node_ = std::make_shared<rapidxml_adapter::xml_document<char>>();
 }

 void parse( std::string str)
 {
 std::shared_ptr<rapidxml_adapter::xml_document<char>> doc_ = std::static_pointer_cast<rapidxml_adapter::xml_document<char>>(node_);
 doc_->parse<rapidxml::parse_no_string_terminators>(str);
 }

 void clear()
 {
 std::shared_ptr<rapidxml_adapter::xml_document<char>> doc_ = std::static_pointer_cast<rapidxml_adapter::xml_document<char>>(node_);
 doc_->clear();
 }
 };

 void xml_check(C* c, bool expr, cpps_value info)
 {
 std::string info_str;
 if (cpps_isstring(info))
 {
 info_str = *cpps_get_string(info);
 }
 
 if (!expr)
 {
 cpps::error(c, "xml_check fail [%s]!!!", info_str.c_str());
 }
 
 }
}