#include "DocVisitor.h"
#include "Util.h"


const float fontSizes[6] = { 12.0f, 30.0f, 24.0f, 18.0f, 14.0f, 10.0f };
const float lineSpacing = 1.5f;
const float spaceFromDotToText = 8.0f;
//const float pageLeftMargin = 60.0f;
//const float pageRightMargin = 60.0f;
//const float pageTopMargin = 120.0f;
//const float pageBottomMargin = 60.0f;


  // <blockquote>     - an indented section            - draw a thick vertical line and indent
  // <pre><code>      - code which is pre-formatted    - interpret white-space literally
  // <code>           - inline quoted text             - italics/highlight


/*
   HPDF_Page_SetTextRenderingMode(page, HPDF_FILL);
   HPDF_Page_SetTextRenderingMode(page, HPDF_STROKE);
*/


DocVisitor::DocVisitor(DocOutputDevice* doc, DocStyle* style, DocTemplate* templ, int pageCount) :
  m_doc(doc),
  m_page(0),
  m_style(style),
  m_templ(templ)
{
  // For pre/code tags, we need to preserve the white space in the contained text
  TiXmlBase::SetCondenseWhiteSpace(false);

  x = y = 0.0f;
  currentStyle.push(FT_Normal);
  currentHeadingLevel.push(0);
  insideCode = 0;
  insideLink = 0;	
  insidePreformatted = 0;
  insideBlockQuote = 0;
  needBlockQuoteBar = false;
  startOfListItem = false;
  insideTable = false;
  alignCenter = false;

  // reset
  FlushBufferedText();

  for (int i = 0; i < 32; i++)
    indentLevels[i] = 30.0f * i;
  indentLevel = 0;

  m_pageNum = 0;
  m_pageCount = pageCount;
  m_needPageCount = false;

  //m_pageLeftMarginX = 60.0f;
  //m_pageRightMarginX = 60.0f;
  //m_pageTopMarginY = 120.0f;
  //m_pageBottomMarginY = 60.0f;

  // defaults
#define HPDF_DEF_PAGE_WIDTH         595.276F
#define HPDF_DEF_PAGE_HEIGHT        841.89F

  Point topLeft;
  Point bottomRight;
  templ->PageBounds(topLeft, bottomRight);

  m_pageLeftMarginX = topLeft.x;
  m_pageTopMarginY = topLeft.y;
  m_pageRightMarginX = bottomRight.x;
  m_pageBottomMarginY = bottomRight.y;

  m_columnCount = 1;
  m_columnSpacing = 20.0;
  
  templ->Columns(m_columnCount, m_columnSpacing);
    
  m_columnNum = m_columnCount - 1;  // Need to start on last column to force an AddPage to happen
  m_truePageLeftMargin = m_pageLeftMarginX;

  float usableWidth = bottomRight.x - topLeft.x;
  m_columnWidth = (usableWidth - ((m_columnCount - 1) * m_columnSpacing)) / m_columnCount;

  m_pageLeftMarginX = m_truePageLeftMargin;
  m_pageRightMarginX = m_pageLeftMarginX + m_columnWidth;
}


DocVisitor::~DocVisitor()
{
  delete m_page; // calls endText
}


void DocVisitor::DrawCodeBlockRect()
{
/*
  // Output a grey-background to the code/preformatted section
  float fontSize = fontSizes[currentHeadingLevel.top()];
  m_page->setFillColor(0xB0F0B0); // light green
  m_page->drawRect(m_pageLeftMarginX, y + m_pageTopMarginY - fontSize,
      m_pageRightMarginX - m_pageLeftMarginX, lineCount * (fontSize * lineSpacing));
*/
}


void SVGTest(const char* a_fileName, double scale, DocOutputPage* outputPage);


void DocVisitor::AddPage() // TODO: rename to NextColumn or something like that
{
  /*
  if (insideCode)
  {
    // output the rectangle around it
    DrawCodeBlockRect();
  }
  */

  // Doing columns in here by having it count which column we are up to
  // and adjusting the left and right margins to make it seem like a thin page
  // That means that the m_page[Top|Left|Right|Bottom]Margin variables are
  // really the bounds for the margin, not the page so should rename these
  m_columnNum++;
  m_pageLeftMarginX += m_columnWidth + m_columnSpacing;
  if (m_columnNum >= m_columnCount)
  {
    m_columnNum = 0;
    m_pageLeftMarginX = m_truePageLeftMargin;

    m_pageNum++;
    if (m_page)
      m_style->adornOldPage(*m_page);
    delete m_page; // calls endText
    m_page = m_doc->newPage();

    // Re-calculate margin positions using the actual page size
    Point topLeft;
    Point bottomRight;
    m_templ->PageBounds(topLeft, bottomRight);
    // internally we used the defaults to save it, undo this
    float rightMargin = HPDF_DEF_PAGE_WIDTH - bottomRight.x;
    float bottomMargin = HPDF_DEF_PAGE_HEIGHT - bottomRight.y;
    // and redo the calc using the actual page size
    m_pageRightMarginX = m_page->width() - rightMargin;
    m_pageBottomMarginY = m_page->height() - bottomMargin;

    float usableWidth = m_pageRightMarginX - m_truePageLeftMargin;
    m_columnWidth = (usableWidth - ((m_columnCount - 1) * m_columnSpacing)) / m_columnCount;
    m_pageRightMarginX = m_pageLeftMarginX + m_columnWidth;

    m_style->adornNewPage(*m_page);
    m_templ->Apply(*m_page);
    
    printf("Start SVG\n");
    //SVGTest("../templates/bars.svg", 0.02, m_page);    
    //SVGTest("../templates/curve.svg", 0.02, m_page);    
    SVGTest("../test-gradient-stops.svg", 0.02, m_page);    
    printf("End SVG\n");
    
    m_page->setFillColor(0);
    m_page->setFontType(currentStyle.top());
    m_page->setFontSize(fontSizes[currentHeadingLevel.top()]);
    
    printf("End new page\n");
  }

  m_pageRightMarginX = m_pageLeftMarginX + m_columnWidth;

  /*
  if (insideCode)
  {
    codeStartX = 0;
    codeStartY = 0;
  }
  */
}


void DocVisitor::CheckIfEndOfPage()
{
  if ((y + m_pageTopMarginY) > m_pageBottomMarginY)
  {
    // Start a new page
    AddPage();
    y = 0.0f;
  }
}


/// Visit a document.
bool DocVisitor::VisitEnter( const TiXmlDocument& /*doc*/ )
{
  AddPage();
  return true;
}


/// Visit a document.
bool DocVisitor::VisitExit( const TiXmlDocument& /*doc*/ )
{
  if (m_page)
    m_style->adornOldPage(*m_page);
  delete m_page; // calls endText
  m_page = 0;
  return true;
}



/// Visit a declaration
bool DocVisitor::Visit(const TiXmlDeclaration& /*declaration*/)
{
  return true;
}


/// Visit a stylesheet reference
bool DocVisitor::Visit(const TiXmlStylesheetReference& /*stylesheet*/)
{
  return true;
}


/// Visit a comment node
bool DocVisitor::Visit( const TiXmlComment& /*comment*/ )
{
  return true;
}


/// Visit an unknown node
bool DocVisitor::Visit(const TiXmlUnknown& /*unknown*/)
{
  return true;
}


void DocVisitor::NewLine(float amount)
{
  x = 0.0f;
  float h = fontSizes[currentHeadingLevel.top()] * lineSpacing * amount;
 
  //needBlockQuoteBar = true;

  m_page->setPenWidth(5.0);
  m_page->setPenColor(0xE0E0E0);
  for (int i = 0; i < insideBlockQuote; i++)
  {
    x += 2.5;
    m_page->drawLine(m_pageLeftMarginX + x, m_pageTopMarginY + y - h * 0.3, m_pageLeftMarginX + x, m_pageTopMarginY + y + h - h * 0.3);
    x += 13.0;
  }
  m_page->setPenWidth(1.0);
  if (!insideBlockQuote)
  {
    m_page->setPenColor(0);
    m_page->setFillColor(0);
  }

  y += h;
  CheckIfEndOfPage();
  if (indentLevel)
    x += indentLevels[indentLevel] + spaceFromDotToText;
}


/// Visit an element.
bool DocVisitor::VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute )
{
  if (strcmp(element.ValueTStr().c_str(), "img") == 0)
  {
    std::string altText = "";
    std::string srcFile = "";
    while (firstAttribute)
    {
      if (firstAttribute->Name() == std::string("alt"))
      {
        altText = firstAttribute->Value();
      }
      else if (firstAttribute->Name() == std::string("src"))
      {
        srcFile = firstAttribute->Value();
      }
      firstAttribute = firstAttribute->Next();
    }
    if (!srcFile.empty() || !altText.empty())
    {
      //printf("image src = %s, alt = %s\n", srcFile.c_str(), altText.c_str());

      // TODO: this is hacky way to get relative path to where images might be - but if this is a new document the
      // user is editing and they haven't saved yet, how do we know which directory to look in?
      // Also perhaps we need to collect up a list of referenced images that are used so they can be copied around together
      // with the markdown file - idea of a bundle - or perhaps multiple docs refer to the same shared library of images
      // so perhaps copied to a specified images directory. Need user preferences for this.

      std::string fileLocation = "../Resources/Documents/" + srcFile;
 
      float w, h;
      bool valid = m_page->imageSize(fileLocation.c_str(), w, h);
      w *= 0.25;
      h *= 0.25;
      if (valid && w > 1.0 && h > 1.0)
      {
        float aspectRatio = w / h;
        int maxWidth = m_pageRightMarginX - m_pageLeftMarginX;
        int maxHeight = m_pageBottomMarginY - m_pageTopMarginY;

        // clamp image to page bounds, maintaining aspect ratio of the image
        if (w > maxWidth)
          w = maxWidth, h = maxWidth / aspectRatio;
        if (h > maxHeight)
          h = maxHeight, w = maxHeight * aspectRatio;

        // Need to check remaining height in page and start new page if not enough
        if ((y + m_pageTopMarginY + h) >= m_pageBottomMarginY)
        {
          AddPage();
          y = 0.0f;
        }

        if (alignCenter)
        {
          // center the image
          NewLine(0.5);
          x = (maxWidth - w) / 2;
        }

        m_page->drawImage(fileLocation.c_str(), x + m_pageLeftMarginX, y + m_pageTopMarginY, w, h);

        x = 0.0;
        y += h;
      }
      else
      {
        // TODO: draw a box around where the image would have been?
        OutputText(altText.c_str());
        NewLine();
      }

    }
  }
  else if (strcmp(element.ValueTStr().c_str(), "p") == 0)
  {
    if (indentLevel == 0)
      NewLine();
  }
  else if (strcmp(element.ValueTStr().c_str(), "ol") == 0)
  {
    orderedList = true;
    listItemIndex = 1;
    NewLine(0.5);
  }
  else if (strcmp(element.ValueTStr().c_str(), "ul") == 0)
  {
    orderedList = false;
    NewLine(0.5);
  }
  else if (strcmp(element.ValueTStr().c_str(), "li") == 0)
  {
    NewLine();
    if (indentLevel)
      x -= indentLevels[indentLevel] + spaceFromDotToText;
    indentLevel++;
    x += indentLevels[indentLevel] + spaceFromDotToText;
    if (orderedList)
    {
      std::string str = std::to_string(listItemIndex) + ".";
     
      x -= spaceFromDotToText;
      //DrawText(m_pageLeftMarginX + x, y + m_pageTopMarginY, str.c_str());
      OutputText(str.c_str());
      x += spaceFromDotToText;

      // TODO: this is not correct across multiple depths of lists - need to have an array of indexes for different list depths
      listItemIndex++;
    }
    else
    {
      // TODO: draw bullet according to style settings (this is hard-coded as a circle/dot bullet)
      m_page->setFillColor(0x0);
      m_page->drawCircle(m_pageLeftMarginX + x - spaceFromDotToText, y + m_pageTopMarginY - fontSizes[currentHeadingLevel.top()] * lineSpacing * 0.25f, 2.0f);
    }
    startOfListItem = true;
  }
  else if (strcmp(element.ValueTStr().c_str(), "code") == 0)
  {
    if (insideCode == 0)
    {
      codeStartX = x;
      codeStartY = y;
      codeText = "";
    
      currentStyle.push(FT_Fixed);
    }
    insideCode++;
  }
  else if (strcmp(element.ValueTStr().c_str(), "a") == 0)
  {

    std::string srcFile = "";
    while (firstAttribute)
    {
      if (firstAttribute->Name() == std::string("href"))
      {
        srcFile = firstAttribute->Value();
      }
      firstAttribute = firstAttribute->Next();
    }
  
    float textHeight = fontSizes[currentHeadingLevel.top()] * lineSpacing * 0.75f;
    m_page->startLink(srcFile.c_str(), m_pageLeftMarginX + x, m_pageTopMarginY + y - textHeight);

    if (insideLink == 0)
      currentStyle.push(FT_Bold);
    insideLink++;
    m_page->setFillColor(0x0000FF); // blue
  }
  else if (strcmp(element.ValueTStr().c_str(), "h1") == 0)
    currentHeadingLevel.push(1), NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "h2") == 0)
    currentHeadingLevel.push(2), NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "h3") == 0)
    currentHeadingLevel.push(3), NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "h4") == 0)
    currentHeadingLevel.push(4), NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "h5") == 0)
    currentHeadingLevel.push(5), NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "strong") == 0)
    currentStyle.push(FT_Bold);
  else if (strcmp(element.ValueTStr().c_str(), "em") == 0)
    currentStyle.push(FT_Oblique);
  else if (strcmp(element.ValueTStr().c_str(), "hr") == 0)
  {
  }
  else if (strcmp(element.ValueTStr().c_str(), "pre") == 0)
  {
    currentStyle.push(FT_Fixed);
    insidePreformatted++;
    NewLine();
  }
  else if (strcmp(element.ValueTStr().c_str(), "br") == 0)
    NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "table") == 0)
  {
    tableData.clear();
    insideTable = true;
  }
  else if (strcmp(element.ValueTStr().c_str(), "thead") == 0)
  {
    // ignore
  }
  else if (strcmp(element.ValueTStr().c_str(), "tbody") == 0)
  {
    // ignore
  }
  else if (strcmp(element.ValueTStr().c_str(), "tr") == 0)
  {
    tableData.emplace_back();
  }
  else if (strcmp(element.ValueTStr().c_str(), "td") == 0 || strcmp(element.ValueTStr().c_str(), "th") == 0)
  {
    std::string styleStr = "";
    while (firstAttribute)
    {
      if (firstAttribute->Name() == std::string("style"))
      {
        styleStr = firstAttribute->Value();
        break;
      }
      firstAttribute = firstAttribute->Next();
    }
    TDAlign align = TDA_Left;
    if (!styleStr.empty())
    {
      if (styleStr == "text-align: center")
        align = TDA_Center;
      else if (styleStr == "text-align: right")
        align = TDA_Right;
      else if (styleStr == "text-align: left")
        align = TDA_Left;
      else
        printf("unexpected table data style: %s\n", styleStr.c_str());
    }
    tableData.back().emplace_back(TD{ align, "" });
  }
  else if (strcmp(element.ValueTStr().c_str(), "blockquote") == 0)
  {
    insideBlockQuote++;  // block quotes can be nested
    m_page->setPenColor(0xE0E0E0);
    m_page->setFillColor(0xA0A0A0);
  }
  else
  {
    return false;
  }
  return true;
}


/// Visit an element.
bool DocVisitor::VisitExit( const TiXmlElement& element )
{
  if (strcmp(element.ValueTStr().c_str(), "img") == 0)
  {
    //NewLine();
  }
  else if (strcmp(element.ValueTStr().c_str(), "p") == 0)
  {
    if (indentLevel == 0)
      NewLine();
  }
  else if (strcmp(element.ValueTStr().c_str(), "ol") == 0)
  {
    if (indentLevel == 0)
      NewLine();
    else
      NewLine(0.5);
  }
  else if (strcmp(element.ValueTStr().c_str(), "ul") == 0)
  {
    if (indentLevel == 0)
      NewLine();
    else
      NewLine(0.5);
  }
  else if (strcmp(element.ValueTStr().c_str(), "li") == 0)
  {
    indentLevel--;
    //NewLine();
  }
  else if (strcmp(element.ValueTStr().c_str(), "code") == 0)
  {
    insideCode--;
    if (insideCode == 0)
    {
      float fontSize = fontSizes[currentHeadingLevel.top()];
      float fh = fontSize * lineSpacing;
      const char* str = codeText.c_str();

      if (insidePreformatted)
      {
        // Count how many lines this code section has
        int lineCount = 0;
        for (int i = 0; str[i] != 0; i++ ) {
          if (str[i] == '\n') {
            lineCount++;
          }	
        }

        //DrawCodeBlockRect();

        // Output a grey-background to the code/preformatted section
        m_page->setPenWidth(1);
        m_page->setFillColor(0xF0F0F0); // light gray
        m_page->setPenColor(0xF0F0F0);  // light gray
        m_page->setAlpha(0.7);
        m_page->drawRect(m_pageLeftMarginX, y + m_pageTopMarginY - fontSize,
            m_pageRightMarginX - m_pageLeftMarginX, (lineCount + 1.5) * fh);

        // Output the code text
        m_page->setFontType(currentStyle.top());
        m_page->setFontSize(fontSize);
        m_page->setFillColor(0); // black
        m_page->setPenColor(0);  // black
        m_page->setAlpha(1.0);

        y += (fontSize * lineSpacing) * 0.75; // half of 1.5 a line-height border
     //   x += (fontSize * lineSpacing) * 0.75; // half of 1.5 a line-height border
      }

      if (!insidePreformatted)
      {
        //insideCode = 1;
        StartRedirect();
      }
      else
      {
        x += (fontSize * lineSpacing) * 1.0; // half a line-height border
      }

      std::string currentWord;
      int i = 0;
      while ( str[i] != 0 ) {
        if ( str[i] == ' ' || str[i] == '\t' || str[i] == '\n' ) {
          //char s[2] = { str[i], 0 };
          //currentWord += s;
          OutputCurrentWord(currentWord.c_str());
          // x -= m_page->textWidth(" ");
          if (str[i] == '\n') {
            NewLine();
            x += (fontSize * lineSpacing) * 1.0; // half a line-height border
          }	
          currentWord = "";
        }
        else
        {
          char s[2] = { str[i], 0 };
          currentWord += s;
        }
        i++;
      }
      if ( str[i] == 0 ) {
        OutputCurrentWord(currentWord.c_str());
        //x -= m_page->textWidth(" ");
      }

      if (!insidePreformatted)
      {
        // insideCode = 0;
        float x1, y1, x2, y2;
        RedirectBounds(x1, y1, x2, y2);

        // Output a grey-background to the code/preformatted section
        m_page->setPenWidth(1);
        m_page->setFillColor(0xF0F0F0); // light gray
        m_page->setPenColor(0xF0F0F0);  // light gray
        
        m_page->setAlpha(0.7);
        m_page->drawRect(x1 - 1.0, y1, x2-x1 + 2.0, y2-y1);
        m_page->setAlpha(1.0);
        /*
        //m_pageLeftMarginX, y + m_pageTopMarginY - fontSize, m_pageRightMarginX - m_pageLeftMarginX, lineCount * (fontSize * lineSpacing));

        // Output the code text
        //m_page->setFontType(currentStyle.top());
        //m_page->setFontSize(fontSize);
        */
        m_page->setFillColor(0); // black
        m_page->setPenColor(0);  // black

        EndRedirect();
      }
      else
      {
        NewLine();
      }
      currentStyle.pop();

      //m_page->setFillColor(0); // black
    }
  }
  else if (strcmp(element.ValueTStr().c_str(), "a") == 0)
  {
    insideLink--;
    if (insideLink == 0)
    {
      float textHeight = fontSizes[currentHeadingLevel.top()] * lineSpacing * 0.25f;
      m_page->endLink(m_pageLeftMarginX + x, m_pageTopMarginY + y + textHeight);
      m_page->setFillColor(0x000000); // black
      currentStyle.pop();
    }
  }
  else if (strcmp(element.ValueTStr().c_str(), "hr") == 0)
  {
    float h = fontSizes[currentHeadingLevel.top()] * lineSpacing * 0.75;
    float y0 = y + m_pageTopMarginY + h;
    m_page->setFillColor(0xF0F0F0); // light gray
    m_page->setPenColor(0xF0F0F0);  // light gray
    //m_page->drawRect(x1, y1, x2, y2);
    // m_page->drawLine(m_pageLeftMarginX, y0, m_pageRightMarginX, y0);
    m_page->drawRect(m_pageLeftMarginX, y0, m_pageRightMarginX - m_pageLeftMarginX, 3.0);
    m_page->setFillColor(0); // black
    m_page->setPenColor(0);  // black
    NewLine(1.5);
  }
  else if (strcmp(element.ValueTStr().c_str(), "h1") == 0) {
    currentHeadingLevel.pop();
    //NewLine();
  }
  else if (strcmp(element.ValueTStr().c_str(), "h2") == 0)
  {
    currentHeadingLevel.pop();
    //NewLine();
    /*
    x = 0.0;
    y += fontSizes[currentHeadingLevel.top()] * lineSpacing * 0.5f;
    m_page->drawLine(m_pageLeftMarginX, y + m_pageTopMarginY, m_pageRightMarginX, y + m_pageTopMarginY);
    y += fontSizes[currentHeadingLevel.top()] * lineSpacing * 0.5f;
    CheckIfEndOfPage();
    */
  }
  else if (strcmp(element.ValueTStr().c_str(), "h3") == 0)
    currentHeadingLevel.pop();//, NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "h4") == 0)
    currentHeadingLevel.pop();//, NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "h5") == 0)
    currentHeadingLevel.pop();//, NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "strong") == 0)
    currentStyle.pop();
  else if (strcmp(element.ValueTStr().c_str(), "em") == 0)
    currentStyle.pop();
  else if (strcmp(element.ValueTStr().c_str(), "pre") == 0)
  {
    insidePreformatted--;
    currentStyle.pop();
  }//	NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "br") == 0)
  {}//	NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "table") == 0)
  {
    insideTable = false;
    OutputTable();
  }
  else if (strcmp(element.ValueTStr().c_str(), "thead") == 0)
  {}//	NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "tbody") == 0)
  {}//	NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "tr") == 0)
  {}//	NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "td") == 0)
  {}//NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "th") == 0)
  {}//	NewLine();
  else if (strcmp(element.ValueTStr().c_str(), "blockquote") == 0)
  {
    insideBlockQuote--;
    if (!insideBlockQuote)
    {
      m_page->setPenColor(0);
      m_page->setFillColor(0);
    }
  }//	NewLine();
  else {
    return false;
  }
  return true;
}


void DocVisitor::RedirectBounds(float& x1, float& y1, float& x2, float& y2)
{
  x1 = std::numeric_limits<float>::max();
  y1 = std::numeric_limits<float>::max();
  x2 = std::numeric_limits<float>::min();
  y2 = std::numeric_limits<float>::min();
  float h = fontSizes[currentHeadingLevel.top()] * lineSpacing * 0.8;
  for (auto& t : redirectedText)
  {
    float w = m_page->textWidth(t.text.c_str());
    float _x1 = t.x;
    float _y1 = t.y - h * 0.75;
    float _x2 = _x1 + w;
    float _y2 = _y1 + h;
    if (_x1 < x1) x1 = _x1;
    if (_y1 < y1) y1 = _y1;
    if (_x2 > x2) x2 = _x2;
    if (_y2 > y2) y2 = _y2;
  }
}


float DocVisitor::WidestWordInText(std::string& str, bool& stretch)
{
  float maxW = 0.0;
  std::vector<std::string> words = split(str, ' ');
  stretch = false;
  if (words.size() >= 2)
  {
    if (words[0] == "<<" && words[words.size()-1] == ">>")
    {
      str = join(std::vector<std::string>(words.begin() + 1, words.end() - 1), " ");
      stretch = true;
    }
  }
  for (auto& word : words)
  {
    float w = m_page->textWidth(word.c_str());
    if (w > maxW)
      maxW = w;
  }
  return maxW;
}


/*
  struct ListState
  {
    bool      ordered;
    int       index;
  };
  struct TextNode
  {
    int          listLevel;
    ListState    listState[16]; // up to 16 nested list levels 
    bool         codeFlag;
    bool         linkFlag;
    bool         blockQuoteFlag;
    bool         italicsFlag;
    bool         boldFlag;
    bool         preFlag;
    bool         tableFlag;
    FontType     style;
    std::string  words;
  };
  float bufferedTextWidth;
  std::vector<TextNode> bufferedText;
*/


void DocVisitor::FlushBufferedText()
{

  bufferedTextWidth = 0.0;
  bufferedText.clear();
}


void DocVisitor::OutputTable()
{
  const float colSpacing = 15.0;
  const float rowSpacing = 2.0;

  float fontSize = fontSizes[0];
  m_page->setFontType(FT_Bold);
  m_page->setFontSize(fontSize);
  m_page->setFillColor(0x0);

  int colCount = 0;
  for (const auto& tr : tableData)
    if (tr.size() > colCount)
      colCount = tr.size();

  int stretchCount = 0;
  std::vector<float> colWidths;     // if no wrapping, what would be the widest width of text in the column
  std::vector<float> minColWidths;  // if wrapping, what would be the smallest width of the column without wrapping mid-word
  std::vector<bool> stretchCols;    // if wrapping, what would be the smallest width of the column without wrapping mid-word
  colWidths.reserve(colCount);
  for (int i = 0; i < colCount; i++)
  {
    colWidths.push_back(0.0);
    minColWidths.push_back(0.0);
    stretchCols.push_back(false);
  }

  for (auto& tr : tableData)
  {
    int col = 0;
    for (auto& td : tr)
    {
      bool stretch = false;
      float w = m_page->textWidth(td.str.c_str());
      if (w > colWidths[col])
        colWidths[col] = w;
      w = WidestWordInText(td.str, stretch);
      if (!stretchCols[col])
      {
        stretchCount += (stretch) ? 1 : 0;
        stretchCols[col] = stretch;
      }
      if (w > minColWidths[col])
        minColWidths[col] = w;
      col++;
    }
  }

  float totalWidth = 0.0;
  for (float w : colWidths)
    totalWidth += w + colSpacing;

  // See if this table is too wide and some columns will need to wrap text over several lines
  float spaceRemaining = m_pageRightMarginX - (m_pageLeftMarginX + totalWidth);
  if (spaceRemaining > 0.0 && stretchCount)
  {
    // the table is not full-width, lets see if any columns are stretched - divide the space left across these
    float spacePerStretchCol = spaceRemaining / stretchCount;
    printf("distributing space to cols: %f\n", spacePerStretchCol);
    for (int i = 0; i < colCount; i++)
    {
      if (stretchCols[i])
        colWidths[i] += spacePerStretchCol;
    }
  }
  float needToReduceBy = -spaceRemaining;
  while (needToReduceBy > 0.0)
  {
    // some lines need to wrap - start with the widest column first
    int col = 0;
    int widestCol = -1;
    float widest = 0.0;
    for (float w : colWidths)
    {
      if (w > widest)
      {
        // skip if already at it's min
        if (w != minColWidths[col])
        {
          widest = w;
          widestCol = col;
        }
      }
      col++;
    }

    // Stop if all columns are already reduced to their mins
    if (widestCol == -1)
      break;

    // halve the column width, or if that is too much, shink it to make the table fit
    float newColWidth = widest * 0.5;
    if (newColWidth > needToReduceBy)
    {
      newColWidth = widest - needToReduceBy;
    }
    // don't resize below what will cause words to be broken mid-word
    if (newColWidth < minColWidths[col])
    {
      newColWidth = minColWidths[col];
    }
    colWidths[widestCol] = newColWidth;
    needToReduceBy -= widest;
    needToReduceBy += newColWidth;
    // this will loop, halving the widest column until they all fit.
    // the theory is that the widest column if wrapped would gain the most
    // but after doing that and wrapping is happening, it will be okay to
    // have other columns wrap if they will be wrapping on same lines as other column
  }

  // recalc
  totalWidth = 0.0;
  for (float w : colWidths)
    totalWidth += w + colSpacing;

  // TODO: we have dropped all formatting inside the table - all text is normal text - need to somehow save the formatting and apply it
  float totalHeight = tableData.size() * (fontSize * lineSpacing + rowSpacing);

  NewLine();
  
  // Check if need to start a new page
  if ((y + m_pageTopMarginY + totalHeight) > m_pageBottomMarginY)
  {
    // Start a new page
    AddPage();
    y = 0.0f;
  }

  m_page->setFontType(FT_Bold);
  m_page->setFontSize(fontSize);
  m_page->setPenColor(0x98bc53);//B0F0B0);
  m_page->setFillColor(0x0);

  float startY = y;
  int row = 0;
  for (const auto& tr : tableData)
  {
    if (alignCenter)
    {
      x += ((m_pageRightMarginX - m_pageLeftMarginX) - totalWidth) * 0.5;
    }

    float y2 = m_pageTopMarginY + y - fontSize * lineSpacing + 3.0;
    m_page->drawLine(m_pageLeftMarginX + x, y2, m_pageLeftMarginX + x + totalWidth, y2);

    //m_page->setPenWidth(0);
    //m_page->setFillColor(0xB0F0B0); // light green

    m_page->setAlpha(0.7);
    m_page->setFillColor((row == 0) ? 0xD0D0D0 : ((row % 2) ? 0xF0F0F0 : 0xE8E8E8)); // light gray
    m_page->drawRect(m_pageLeftMarginX + x, y2, totalWidth, fontSize * lineSpacing + rowSpacing);
    m_page->setFillColor(0);
    m_page->setAlpha(1.0);

    int col = 0;
    for (const auto& td : tr)
    {
      // OutputText(str);
      float strW = m_page->textWidth(td.str.c_str());
      float colW = colWidths[col] + colSpacing;
      if ( td.align == TDA_Left )
        m_page->drawText(m_pageLeftMarginX + x + (colSpacing * 0.5), y + m_pageTopMarginY, td.str.c_str());
      else if ( td.align == TDA_Center )
        m_page->drawText(m_pageLeftMarginX + x + ((colW - strW) * 0.5), y + m_pageTopMarginY, td.str.c_str());
      else if ( td.align == TDA_Right )
        m_page->drawText(m_pageLeftMarginX + x + colW - strW - (colSpacing * 0.5), y + m_pageTopMarginY, td.str.c_str());
      x += colW;
      col++;
    }
    x = 0.0;
    y += fontSize * lineSpacing + rowSpacing;
    if (row == 0)
      m_page->setFontType(FT_Normal);
    row++;
  }
  if (alignCenter)
  {
    x += ((m_pageRightMarginX - m_pageLeftMarginX) - totalWidth) * 0.5;
  }
  float y2 = m_pageTopMarginY + y - fontSize * lineSpacing + 3.0;
  m_page->drawLine(m_pageLeftMarginX + x, y2, m_pageLeftMarginX + x + totalWidth, y2);

  // Draw the vertical lines
  x = 0.0;
  float y1 = m_pageTopMarginY + startY - fontSize * lineSpacing + 3.0;
  for (int i = 0; i < colCount; i++)
  {
    if (alignCenter)
    {
      x += ((m_pageRightMarginX - m_pageLeftMarginX) - totalWidth) * 0.5;
    }

    m_page->drawLine(m_pageLeftMarginX + x, y1, m_pageLeftMarginX + x, y1 + totalHeight);
    x += colWidths[i] + colSpacing;
  }
  m_page->drawLine(m_pageLeftMarginX + x, y1, m_pageLeftMarginX + x, y1 + totalHeight);
  x = 0.0;
}


static std::vector<std::string> split_keep_delim(const std::string &s, char delim, bool splitBefore=true)
{
	std::vector<std::string> elems;
  std::string cur;
  for (char c : s)
  {
    if (splitBefore && c == delim && !cur.empty())
    {
      elems.push_back(cur);
      cur = "";
    }
    cur += c;
    if (!splitBefore && c == delim)
    {
      elems.push_back(cur);
      cur = "";
    }
  }
  if (!cur.empty())
    elems.push_back(cur);
	return elems;
}


float DocVisitor::OutputTextHelper(const char* str, bool doSplit)
{
  std::string sstr(str);
  const auto p1 = sstr.find('[');
  const auto p2 = sstr.find(']');
  if (doSplit && p1 != std::string::npos && p2 != std::string::npos)
  {
    for (const auto& str2 : split_keep_delim(str, '['))
    {
      if ((x + 50) >= m_pageRightMarginX)
      {
        NewLine();
      }
    
      for (const auto& str3 : split_keep_delim(str2, ']', false))
      {
        // x += OutputTextHelper(("XX" + str3 + "YY").c_str(), false);
        x += OutputTextHelper(str3.c_str(), false);
      }
    }
    return 0.0;
  }

  if (sstr == "<center>")
  {
    alignCenter = true;
    return 0;
  }
  else if (sstr == "</center>")
  {
    alignCenter = false;
    return 0;
  }

  // Custom page-break markdown  (TODO: probably shouldn't be parsing markdown in here)
  //   - yep, if output html, we would want that filtered out from the html, so where to parse this?
  if (sstr == "<<<<<>>>>>" || sstr == "--<<>>--")
  {
    // Start a new page
    AddPage();
    y = 0.0f;
    x = 0.0f;
    return 0;
  }
  // TODO: be able to insert [AUTHOR], [TITLE], [VERSION], [COMPANY] and [COPYRIGHT] - can do, but it is [%TITLE] etc
  //       and also for the below, probably need to filter out from when doing html output, so probably this is
  //       not the right place to make these substitutions
  else if (sstr == "[PAGENUM]")
  {
    std::string num = std::to_string(m_pageNum);
    return OutputTextHelper(num.c_str());
  }
  else if (sstr == "[PAGECOUNT]")
  {
    if (m_pageCount > 0)
    {
      std::string num = std::to_string(m_pageCount);
      return OutputTextHelper(num.c_str());
    }
    else
    {
      // needs to output/parse the PDF twice, once to determine the page count and second time to insert it
      m_needPageCount = true;
      return OutputTextHelper("-1");
    }
  }
  else if (sstr == "[DATE]")
  {
    std::string datestr = get_date_string("%A, %e %B %Y");
    return OutputTextHelper(datestr.c_str());
  }
  else if (sstr == "[TIME]")
  {
    std::string datestr = get_date_string("%X");
    return OutputTextHelper(datestr.c_str());
  }
  else if (sstr == "[TIMESTAMP]")
  {
    std::string datestr = get_date_string("%F %X");
    return OutputTextHelper(datestr.c_str());
  }

  float w = m_page->textWidth(str);

  /*
     if (insideCode)// || insideLink)
     {
     m_page->drawRect(m_pageLeftMarginX + x - 1, y + m_pageTopMarginY + 2, w + 2, fontSizes[currentHeadingLevel.top()] + 2);

     if (insideCode)
     m_page->setColor(0.1f, 0.1f, 0.1f); // dark green
     else
     m_page->setColor(0.3f, 0.3f, 1.0f); // blue
     }
     */

  /*
  if (insideCode)
  {
    // Output a grey-background to the code/preformatted section
    float fontSize = fontSizes[currentHeadingLevel.top()];
    m_page->setPenWidth(0);
    m_page->setFillColor(0xB0F0B0); // light green
    m_page->drawRect(m_pageLeftMarginX + x, y + m_pageTopMarginY - fontSize, w, fontSize * lineSpacing);
    
    // Output the code text
    m_page->setFontType(currentStyle.top());
    m_page->setFontSize(fontSize);
    m_page->setFillColor(0x208010); // dark green
  }
  */

  DrawText(m_pageLeftMarginX + x, y + m_pageTopMarginY, str);

  /*
  if (insideCode)
  {
    m_page->setFillColor(0); // black
  }
  */

  return w;
}


// outputs current word to pdf
// splits the string up by words if it has to, and outputs new words on a new line if it will over fill the current line
// but also if the word is too big for a complete line, then will split that word mid-word as needed.
void DocVisitor::OutputCurrentWord(const char* str)
{
  if (!str || !str[0])
    return;

  // Need to see if need to break mid-word if the word is too long for the line
  float wordWidthAndMargins = m_pageLeftMarginX + m_page->textWidth(str);

  if ((wordWidthAndMargins + x) >= m_pageRightMarginX) // Checking if it can fit on the current line or not
  {
    if (wordWidthAndMargins >= m_pageRightMarginX) // Can it fit on a new line by itself?
    {
      // we need to break up the text, write it char by char
      int i = 0;
      while (str[i]) {
        char s[2] = { str[i], 0 };
        // TODO: adding the dash is okay if the text is English, but not if text is other language, eg Japanese or Chinese
        float chWidthAndMargins = m_pageLeftMarginX + m_page->textWidth(s) + m_page->textWidth("-");
        if ((chWidthAndMargins + x) >= m_pageRightMarginX)
        {
          OutputTextHelper("-");
          NewLine();
        }
        x += OutputTextHelper(s);
        i++;
      }
      x += m_page->textWidth(" ");//OutputTextHelper(" ");
      /*
      float spaceWidth = m_page->textWidth(" ");
      if (insideCode)
      {
        // Output a grey-background to the code/preformatted section
        float fontSize = fontSizes[currentHeadingLevel.top()];
        m_page->setPenWidth(0);
        m_page->setFillColor(0xB0F0B0); // light green
        m_page->drawRect(m_pageLeftMarginX + x, y + m_pageTopMarginY - fontSize, spaceWidth, fontSize * lineSpacing);
      }
      x += spaceWidth;
      */
      return;
    }
    else
    {
      NewLine();
    }
  }
  x += OutputTextHelper(str);
  x += m_page->textWidth(" ");//OutputTextHelper(" ");//m_page->textWidth(" ");
}


void DocVisitor::OutputText(const char* str)
{
  if (insideTable)
  {
    tableData.back().back().str += str;
    return;
  }

  if (insideCode)
  {
    codeText += str;
    return;
  }

  m_page->setFontType(currentStyle.top());
  m_page->setFontSize(fontSizes[currentHeadingLevel.top()]);

  // if (startOfListItem)
  {
    if (strlen(str) >= 3 && str[0] == '[' && str[2] == ']')
    {
      bool checked = str[1] == 'x' || str[1] == 'X';
      float textHeight = fontSizes[currentHeadingLevel.top()] * lineSpacing * 0.75;
      m_page->drawCheckBox(checked, m_pageLeftMarginX + x, m_pageTopMarginY + y - textHeight, textHeight, textHeight);
      x += textHeight * 1.5;
      str += 3;
    }
    startOfListItem = false;
  }

  std::string currentWord;
  int i = 0;
  while ( str[i] != 0 ) {
    if ( str[i] == ' ' || str[i] == '\t' || str[i] == '\n' ) {
      OutputCurrentWord(currentWord.c_str());

      if (insideCode && str[i] == '\n') { // for html, this is wrong
        NewLine();
      }	

      currentWord = "";
      //break;
    }
    else
    {
      char s[2] = { str[i], 0 };
      currentWord += s;
    }
    i++;
  }
  //if ( str[i] == 0 ) {
  if ( !currentWord.empty() ) {
    OutputCurrentWord(currentWord.c_str());
  }
}


/// Visit a text node
bool DocVisitor::Visit( const TiXmlText& text )
{
  const char* str = text.ValueTStr().c_str();
  OutputText(str);
  return true;
}