#include <libxml/parser.h>

#include "GUILoader.hh"
#include "FontProvider.hh"
#include "ImageProvider.hh"
#include "Widget.hh"
#include "TextWidget.hh"
#include "LinearLayout.hh"

struct Style {
  int width{WRAP_CONTENT}, height{WRAP_CONTENT};
  SDL_Surface *background{nullptr};
  SDL_Color bg{0, 0, 0, 255}, fg{255, 255, 255, 255};
  int padLeft{0}, padTop{0}, padRight{0}, padBottom{0};
  int alignHoriz{ALIGN_LEFT}, alignVert{ALIGN_TOP};
  int alignContHoriz{ALIGN_LEFT}, alignContVert{ALIGN_TOP};
  TTF_Font *font{nullptr};
};

class GUISAXParser {
public:
  GUISAXParser() : state_(State::S_INITIAL), root_(nullptr) {
  }

  std::unique_ptr<Widget> getResult() {
    return std::move(root_);
  }

  void startDocument() {
    printf("startDocument()\n");
    state_ = State::S_INITIAL;
  }

  void endDocument() {
    printf("endDocument()\n");
    if (state_ != State::S_FINISHED)
      throw Exception{"Invalid state at document end"};
  }

  void startElement(const xmlChar *name, const xmlChar **attrs) {
    printf("startElement(%s)\n", name);
    const std::string ename{reinterpret_cast<char const*>(name)};
    std::unordered_map<std::string, std::string> eattrs;
    while (*attrs != nullptr) {
      std::string k{reinterpret_cast<char const*>(*attrs)},
	v{reinterpret_cast<char const*>(*(attrs+1))};

      eattrs[k] = v;
      attrs += 2;
    }
    
    
    if (state_ == State::S_STYLE)
      throw Exception{"Invalid Element inside <style>"};

    if ((state_ == State::S_DONE) || (state_ == State::S_FINISHED))
      throw Exception{"Invalid state in startElement"};

    if (ename == "gui") {
      if (state_ != State::S_INITIAL)
	throw Exception{"Invalid state in <gui>"};
      printf("state -> S_GUI\n");
      state_ = State::S_GUI;
    } else if (ename ==  "style") {
      if (state_ != State::S_GUI)
	throw Exception{"Invalid state in <style>"};
      
      printf("state -> S_STYLE\n");
      state_ = State::S_STYLE;

      auto it = eattrs.find("name");
      if (it == eattrs.end())
	throw Exception{"Style missing required attr \"name\""};

      Style style;
      for(auto& ent : eattrs) {
	if (ent.first == "width")
	  style.width = parseDimension(ent.second);
	else if (ent.first == "height")
	  style.height = parseDimension(ent.second);
	else if (ent.first == "background")
	  style.background = ImageProvider::getInstance().getImage(ent.second);
	else if (ent.first == "backgroundColor")
	  style.bg = parseColor(ent.second);
	else if (ent.first == "color")
	  style.fg = parseColor(ent.second);
	else if (ent.first == "paddingLeft")
	  style.padLeft = std::stoi(ent.second);
	else if (ent.first == "paddingTop")
	  style.padTop = std::stoi(ent.second);
	else if (ent.first == "paddingRight")
	  style.padRight = std::stoi(ent.second);
	else if (ent.first == "paddingBottom")
	  style.padBottom = std::stoi(ent.second);
	else if (ent.first == "alignHorizontal")
	  style.alignHoriz = parseAlign(ent.second);
	else if (ent.first == "alignVertical")
	  style.alignVert = parseAlign(ent.second);
	else if (ent.first == "containerAlignHorizontal")
	  style.alignContHoriz = parseAlign(ent.second);
	else if (ent.first == "containerAlignVertical")
	  style.alignContVert = parseAlign(ent.second);
	else if (ent.first == "font") {
	  auto fi = parseFont(ent.second);
	  style.font = FontProvider::getInstance().getFont(std::get<0>(fi), std::get<1>(fi));
	} else if (ent.first == "name") {
	} else
	  printf("Warning: Unknown style attribute \"%s\"\n", ent.first.c_str());
      }

      styles_[eattrs["name"]] = style;
    } else if ((ename == "LinearLayout") ||
	       (ename == "TextWidget")) {
      if ((state_ != State::S_GUI) && (state_ != State::S_WIDGETS))
	throw Exception{"Invalid state in <Widget>"};
      
      std::unique_ptr<Widget> widget;

      // Find name
      std::string name{""};
      auto it = eattrs.find("name");
      if (it != eattrs.end())
	name = it->second;

      // Find and copy style if given
      Style style;
      it = eattrs.find("style");
      if (it != eattrs.end())
	style = styles_.at(it->second);

      int width = style.width, height = style.height;
      
      it = eattrs.find("width");
      if (it != eattrs.end())
	width = parseDimension(it->second);

      it = eattrs.find("height");
      if (it != eattrs.end())
	height = parseDimension(it->second);
	
      // Construct widget
      if (ename == "LinearLayout") {
	int direction = DIR_VERTICAL;
	it = eattrs.find("direction");
	if (it != eattrs.end()) {
	  if (it->second == "horizontal")
	    direction = DIR_HORIZONTAL;
	  else if (it->second == "vertical")
	    direction = DIR_VERTICAL;
	  else
	    throw Exception{"Invalid direction"};
	}

	int childPadding = 0;
	it = eattrs.find("childPadding");
	if (it != eattrs.end())
	  childPadding = std::stoi(it->second);
	
	widget = make_unique<LinearLayout>(direction, width, height, name);
	static_cast<LinearLayout&>(*widget).setChildPadding(childPadding);
      } else if (ename == "TextWidget") {
	std::string text{};
	TTF_Font *font = style.font;

	it = eattrs.find("text");
	if (it != eattrs.end())
	  text = it->second;

	it = eattrs.find("font");
	if (it != eattrs.end()) {
	  auto fi = parseFont(it->second);
	  font = FontProvider::getInstance().getFont(std::get<0>(fi), std::get<1>(fi));
	}
	
	widget = make_unique<TextWidget>(font, text, width, height, name);
      } else
	throw Exception{"Invalid Widget"};

      // Apply style
      for(auto& ent : eattrs) {
	if (ent.first == "background")
	  style.background = ImageProvider::getInstance().getImage(ent.second);
	else if (ent.first == "backgroundColor")
	  style.bg = parseColor(ent.second);
	else if (ent.first == "color")
	  style.fg = parseColor(ent.second);
	else if (ent.first == "paddingLeft")
	  style.padLeft = std::stoi(ent.second);
	else if (ent.first == "paddingTop")
	  style.padTop = std::stoi(ent.second);
	else if (ent.first == "paddingRight")
	  style.padRight = std::stoi(ent.second);
	else if (ent.first == "paddingBottom")
	  style.padBottom = std::stoi(ent.second);
	else if (ent.first == "alignHorizontal")
	  style.alignHoriz = parseAlign(ent.second);
	else if (ent.first == "alignVertical")
	  style.alignVert = parseAlign(ent.second);
	else if (ent.first == "containerAlignHorizontal")
	  style.alignContHoriz = parseAlign(ent.second);
	else if (ent.first == "containerAlignVertical")
	  style.alignContVert = parseAlign(ent.second);
      }

      if (style.background)
	widget->setBackground(style.background);

      if (style.bg != SDL_Color{0, 0, 0, 255})
	widget->setBackgroundColor(style.bg);
      if (style.fg != SDL_Color{255, 255, 255, 255})
	widget->setForegroundColor(style.fg);

      if ((style.padLeft != 0) || (style.padTop != 0) || (style.padRight != 0) ||
	  (style.padBottom != 0))
	widget->setPadding(style.padLeft, style.padTop, style.padRight,
			   style.padBottom);

      if ((style.alignHoriz != ALIGN_LEFT) || (style.alignVert != ALIGN_TOP))
	widget->setAlignment(style.alignHoriz, style.alignVert);
      if ((style.alignContHoriz != ALIGN_LEFT) || (style.alignContVert != ALIGN_TOP))
	widget->setContainerAlignment(style.alignContHoriz, style.alignContVert);
      
      
      if (state_ == State::S_GUI) {
	printf("state -> S_WIDGETS\n");
	state_ = State::S_WIDGETS;

	stack_.push_back(widget.get());
	root_ = std::move(widget);
      } else if (state_ == State::S_WIDGETS) {
	View* view = dynamic_cast<View*>(stack_.back());
	stack_.push_back(widget.get());
	view->addChild(std::move(widget));
      }
    } else
      throw Exception{"Invalid element"};
  }
  
  void endElement(const xmlChar *name) {
    printf("endElement(%s)\n", name);
    const std::string ename{reinterpret_cast<char const*>(name)};
    
    if (ename == "style") {
      if (state_ != State::S_STYLE)
	throw Exception{"Invalid state on </style>"};
      printf("state -> S_GUI\n");
      state_ = State::S_GUI;
      return;
    }

    if ((ename == "LinearLayout") ||
	(ename == "TextWidget")) {
      if (state_ != State::S_WIDGETS)
	throw Exception{"Invalid state on </Widget>"};

      assert(!stack_.empty());
      stack_.pop_back();
      if (stack_.empty()) {
	printf("state -> S_DONE\n");
	state_ = State::S_DONE;
      }
      return;
    }

    if (ename == "gui") {
      if (state_ != State::S_DONE)
	throw Exception{"Invalid state on </gui>"};

      printf("state -> S_FINISHED\n");
      state_ = State::S_FINISHED;
      return;
    }
    throw Exception{"Invalid element"};
  }
  
private:
  enum class State {
    S_INITIAL,
      S_GUI,
      S_STYLE,
      S_WIDGETS,
      S_DONE,
      S_FINISHED
  };

  int parseDimension(std::string const& str) {
    if (str == "match_parent")
      return MATCH_PARENT;
    else if (str == "wrap_content")
      return WRAP_CONTENT;
    else if (str == "wrap_content_fill")
      return WRAP_CONTENT_FILL;
    
    try {
      return std::stoi(str);
    } catch (std::invalid_argument &ex) {
      throw Exception{"Invalid dimension"};
    }
  }

  int parseAlign(std::string const& str) {
    if (str == "center")
      return ALIGN_CENTER;
    else if (str == "left")
      return ALIGN_LEFT;
    else if (str == "right")
      return ALIGN_RIGHT;
    else if (str == "top")
      return ALIGN_TOP;
    else if (str == "bottom")
      return ALIGN_BOTTOM;

    throw Exception{"Invalid alignment"};
  }
  
  SDL_Color parseColor(std::string const& str) {
    SDL_Color ret;
    auto sep = str.find(',');
    if (sep == std::string::npos)
      throw Exception{"Invalid color"};
    
    try {
      ret.r = std::stoi(str.substr(0, sep));
      
      auto lastsep = sep;
      sep = str.find(',', sep+1);
      if (sep == std::string::npos)
	throw Exception{"Invalid color"};
      ret.g = std::stoi(str.substr(lastsep+1, sep-lastsep));
      
      lastsep = sep;
      sep = str.find(',', sep+1);
      bool alpha = true;
      if (sep == std::string::npos)
        alpha = false;
      ret.b = std::stoi(str.substr(lastsep+1, sep-lastsep));
      
      if (!alpha)
	ret.a = 255;
      else
	ret.a = std::stoi(str.substr(sep+1));
    } catch (std::invalid_argument &ex) {
      throw Exception{"Invalid color"};
    }
    
    return ret;
  }
      
  std::tuple<std::string, unsigned> parseFont(std::string const& str) {
    auto sep = str.find(',');
    if (sep == std::string::npos)
      return make_tuple(str, 12);
    else
      return make_tuple(str.substr(0, sep), std::stoi(str.substr(sep+1)));
  }
  
  State state_;

  std::vector<Widget*> stack_;
  std::unique_ptr<Widget> root_;
  std::unordered_map<std::string, Style> styles_;
};

static void _startDocument(void *userdata) {
  static_cast<GUISAXParser*>(userdata)->startDocument();
}

static void _endDocument(void *userdata) {
  static_cast<GUISAXParser*>(userdata)->endDocument();
}

static void _startElement(void *userdata, const xmlChar *name,
			  const xmlChar **attrs) {
  static_cast<GUISAXParser*>(userdata)->startElement(name, attrs);
}

static void _endElement(void *userdata, const xmlChar *name) {
  static_cast<GUISAXParser*>(userdata)->endElement(name);
}



static xmlSAXHandler saxHandlers{
  nullptr, // internalSubsetSAXFunc internalSubset;
  nullptr, // isStandaloneSAXFunc isStandalone;
  nullptr, // hasInternalSubsetSAXFunc hasInternalSubset;
  nullptr, // hasExternalSubsetSAXFunc hasExternalSubset;
  nullptr, // resolveEntitySAXFunc resolveEntity;
  nullptr, // getEntitySAXFunc getEntity;
  nullptr, // entityDeclSAXFunc entityDecl;
  nullptr, // notationDeclSAXFunc notationDecl;
  nullptr, // attributeDeclSAXFunc attributeDecl;
  nullptr, // elementDeclSAXFunc elementDecl;
  nullptr, // unparsedEntityDeclSAXFunc unparsedEntityDecl;
  nullptr, // setDocumentLocatorSAXFunc setDocumentLocator;
  &_startDocument, // startDocumentSAXFunc startDocument;
  &_endDocument, // endDocumentSAXFunc endDocument;
  &_startElement, // startElementSAXFunc startElement;
  &_endElement, // endElementSAXFunc endElement;
  nullptr, // referenceSAXFunc reference;
  nullptr, // charactersSAXFunc characters;
  nullptr, // ignorableWhitespaceSAXFunc ignorableWhitespace;
  nullptr, // processingInstructionSAXFunc processingInstruction;
  nullptr, // commentSAXFunc comment;
  nullptr, // warningSAXFunc warning;
  nullptr, // errorSAXFunc error;
  nullptr, // fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
  nullptr, // getParameterEntitySAXFunc getParameterEntity;
  nullptr, // cdataBlockSAXFunc cdataBlock;
  nullptr,  // externalSubsetSAXFunc externalSubset;
  false, // unsigned int initialized;
  // /* The following fields are extensions available only on version 2 */
  nullptr, // void *_private;
  nullptr, // startElementNsSAX2Func startElementNs;
  nullptr, // endElementNsSAX2Func endElementNs;
  nullptr // xmlStructuredErrorFunc serror;
    };

std::unique_ptr<Widget> loadGUIFromFile(std::string const& filename)
{
  GUISAXParser parser{};
  xmlSAXUserParseFile(&saxHandlers, &parser, filename.c_str());

  return parser.getResult();
}