#include <cstdarg>
#include <cstdlib>
#include <string>
#include <iostream>
#include "DocTemplate.h"
#include "Util.h"
#define HPDF_DEF_PAGE_WIDTH         595.276F
#define HPDF_DEF_PAGE_HEIGHT        841.89F


GENERATE_ENUM_SERIALIZATION_FUNCTIONS
(
 DocItemType,
 DIT_Last,
 DIT_Unknown,
 "Defaults",
 "Page",
 "Background",
 "Label",
 "Image",
 "Line",
 "Box",
 "Circle",
 "Ellipse",
 "Polygon",
 "Spline",
 "Shape",
 "Unknown"
)


GENERATE_ENUM_SERIALIZATION_FUNCTIONS
(
 TemplateRole,
 TR_Last,
 TR_Both,
 "CoverPage",
 "Document",
 "Both"
)


GENERATE_ENUM_SERIALIZATION_FUNCTIONS
(
 PenStyle,
 PS_Last,
 PS_Solid,
 "Solid",
 "Dashed"
)


std::string   DocTemplate::m_currentFile = "";
unsigned int  DocTemplate::m_currentLine = 0;


#define DebugMsg(fmt, ...)	DocTemplate::LogMessage(LL_Debug, fmt, ##__VA_ARGS__)
#define WarningMsg(fmt, ...)	DocTemplate::LogMessage(LL_Warning, fmt, ##__VA_ARGS__)
#define ErrorMsg(fmt, ...)	DocTemplate::LogMessage(LL_Error, fmt, ##__VA_ARGS__)


#ifndef _WIN32
#  define HAVE_CONSTEXPR
#else
#  include <windows.h>
#endif

#ifdef HAVE_CONSTEXPR

// TODO: XXX ### This side of HAVE_CONSTEXPR has not been tested
constexpr unsigned int hashString(const char* str, int h = 0)
{
	return !str[h] ? 5381 : (hashString(str, h + 1) * 33) ^ str[h];
}
unsigned int hashString(const std::string& str, int h = 0)
{
	return !str.c_str()[h] ? 5381 : (hashString(str, h + 1) * 33) ^ str.c_str()[h];
}

// Assumes that for lower case comparing, the values passed in are already lower case
#define Choose(x)       do { std::string tttmp = x; switch (hashString(x)) {
#define Option(x)       } case hashString(x): if ( tttmp == x ) {
#define OptionLower(x)  } case hashString(x): if ( str2lower(tttmp) == str2lower(std::string(x)) ) {
#define Defaults        } default: {
#define Done            } } while(false);

#else

#define Choose(x)       do { std::string tttmp = x; if (false)
#define Option(x)       } else if ( tttmp == x ) {
#define OptionLower(x)  } else if ( str2lower(tttmp) == str2lower(std::string(x)) ) {
#define Defaults        } else {
#define Done            } while(false);

#endif

/*

// auto means this will work with ints too (but depends how str2lower is defined)
// but means it won't work with const char*s.
#define strSwitch(x)    do { auto tttmp = x; if (false)
#define strCase(x)      } else if ( tttmp == x ) {
#define strLowerCase(x) } else if ( str2lower(tttmp) == str2lower(std::string(x)) ) {
#define strDefault      } else {
#define strSwitchEnd    } while(false);

*/


/*

Rules:	Any extra white space is allowed, but if the the value, must be quoted,
eg:
		text = Blah         is okay
		text = Foo Bar      is not okay, must be quoted
		text = "Foo Bar"    is okay

		pos = 10,10         is okay
		pos = 10, 10        is not okay, must be quoted
		pos = "10, 10"      is okay

Removal of extra white space around the '=' is fine
eg:
		pos = 10,10         is okay
		pos= 10,10          is okay
		pos =10,10          is okay
		pos=10,10           is okay

Attributes must be deliminated by white space
eg:
		foo=val1 bar=val2   is okay
		foo=val1bar=val2    is not okay
		foo="val1"bar=val2  is not okay (but might work as you expect, but don't count on it)

*/


DocTemplate::DocTemplate()
{
	m_defaultDefaults.m_type = DIT_Defaults;
	m_defaultDefaults.m_role = TR_Both;
	m_defaultDefaults.m_alpha = 1.0;
	m_defaultDefaults.m_bgColor = 0xffffff;
	m_defaultDefaults.m_pos.x = 10.0;
	m_defaultDefaults.m_pos.y = 10.0;
	m_defaultDefaults.m_size.x = 100.0;
	m_defaultDefaults.m_size.y = 100.0;
	m_defaultDefaults.m_font = "Helvetica";
	m_defaultDefaults.m_fontSize = 12.0f;
	m_defaultDefaults.m_fontColor = 0x000000;
	m_defaultDefaults.m_fillColor = 0x000000;
	m_defaultDefaults.m_penColor = 0x000000;
	m_defaultDefaults.m_penWidth = 1.0f;
	m_defaultDefaults.m_penStyle = PS_Solid;
	m_defaultDefaults.m_alignment = Align((int)AL_Left | (int)AL_Top);
	m_defaultDefaults.m_boundsAlignment = Align((int)AL_Left | (int)AL_Top);
  m_defaultDefaults.m_text = "undefined";
	m_defaultDefaults.m_imageFile = "undefined";
	m_defaults = m_defaultDefaults;
  m_pageTopLeft.x = 60.0;
  m_pageTopLeft.y = 120.0;
  m_pageBottomRight.x = HPDF_DEF_PAGE_WIDTH - 60.0;
  m_pageBottomRight.y = HPDF_DEF_PAGE_HEIGHT - 60.0;
  m_columns = 1;
  m_columnSpacing = 20.0;
}


DocTemplate::~DocTemplate()
{
}


#ifndef _WIN32
int _vscprintf(const char * format, va_list pargs)
{
	int retval;
	va_list argcopy;
	va_copy(argcopy, pargs);
	retval = vsnprintf(NULL, 0, format, argcopy);
	va_end(argcopy);
	return retval;
}
#endif


void DocTemplate::LogMessage(yqLogLevel a_level, const char* a_msg, ...)
{
	va_list args;
	va_start(args, a_msg);
#ifdef _WIN32
	auto sizeForFileLineAndNull = m_currentFile.size() + 64 + 1;
	auto sizeRequired = _vscprintf(a_msg, args) + sizeForFileLineAndNull;
	auto a = (char*)_alloca(sizeRequired);
	int offset = _snprintf_s(a, sizeRequired, sizeForFileLineAndNull, "%s(%i): ", m_currentFile.c_str(), m_currentLine);
	vsnprintf_s(a + offset, sizeRequired - offset, INT_MAX - 1, a_msg, args);
	OutputDebugStringA(a);
	_freea(a);
#else
	vfprintf(stderr, a_msg, args);
#endif
	va_end(args);
	/*
	if (a_level == LL_Warning)
		DebugBreak();
	*/
	if (a_level == LL_Error)
		exit(-1);
}


std::vector<Point> str2pointList(const std::string& str)
{
	std::vector<Point> ret;
	std::vector<std::string> strs = split(str, ',');
	for (size_t i = 0; i < strs.size(); i+=2)
	{
		Point pnt = { 0, 0 };
		pnt.x = (float)atof(trim(strs[i + 0]).c_str());
		if ((i + 1) < strs.size())
			pnt.y = (float)atof(trim(strs[i + 1]).c_str());
		else
			WarningMsg("uneven coordinate count in shape, expecting a list of 2d coordinates so should be even count!\n");
		ret.push_back(pnt);
	}
	return ret;
}
std::vector<Point> stringToPolygon(const std::string& str)
{
  return str2pointList(str);
}


Point str2pos(const std::string& str)
{
	Point ret = { 0, 0 };
	std::vector<std::string> strs = split(str, ',');
  if (strs.size() != 2)
    return ret;
	ret.x = (float)atof(trim(strs[0]).c_str());
	ret.y = (float)atof(trim(strs[1]).c_str());
	return ret;
}
Point stringToPoint(const std::string& str)
{
  return str2pos(str);
}


PenStyle str2style(const std::string& str)
{
	Choose(str)
	{
		OptionLower("Solid")
			return PS_Solid;
		OptionLower("Dashed")
			return PS_Dashed;
		Defaults
			WarningMsg("Bad style\n");
			break;
	}
	Done
	return PS_Solid;
}


Align str2align(const std::string& str)
{
  if (str.empty())
  {
    return (Align)(AL_Left | AL_Top);
  }
	unsigned int alignment = 0;
	std::vector<std::string> strs = split(str, ',');
	std::string horzStr = trim(strs[0]);

  // if both are center, then one is hcenter and other is vcenter
  // if only one is center, we can determine if it is a hcenter or vcenter by the other value
  // we do this after first attempting to parse it

	Choose(horzStr)
	{
		OptionLower("left")   alignment |= AL_Left;    break;
		OptionLower("right")  alignment |= AL_Right;   break;
		OptionLower("top")    alignment |= AL_Top;     break;
		OptionLower("bottom") alignment |= AL_Bottom;  break;
		OptionLower("center") alignment |= AL_HCenter; break;
		OptionLower("centre") alignment |= AL_HCenter; break;
		Defaults
			WarningMsg("Bad horizontal alignment\n");
			break;
	}
	Done

  if (strs.size() < 2)
  {
    return (Align)(alignment | AL_Top);
  }
	std::string vertStr = trim(strs[1]);
	Choose(vertStr)
	{
		OptionLower("left")   alignment |= AL_Left;    break;
		OptionLower("right")  alignment |= AL_Right;   break;
		OptionLower("top")    alignment |= AL_Top;     break;
		OptionLower("bottom") alignment |= AL_Bottom;  break;
		OptionLower("center") alignment |= AL_VCenter; break;
		OptionLower("centre") alignment |= AL_VCenter; break;
		Defaults
			WarningMsg("Bad vertical alignment\n");
		break;
	}
	Done

	// check we have a valid combination
	if ((alignment & (AL_Left | AL_HCenter | AL_Right)) && (alignment & (AL_Top | AL_VCenter | AL_Bottom)))
		return (Align)alignment;

	// for it to still be valid, then one of the values is a center, swap the center types and try again
	if (alignment & AL_HCenter)
		alignment = (alignment & ~AL_HCenter) | AL_VCenter;
	else if (alignment & AL_VCenter)
		alignment = (alignment & ~AL_VCenter) | AL_HCenter;

	if ((alignment & (AL_Left | AL_HCenter | AL_Right)) && (alignment & (AL_Top | AL_VCenter | AL_Bottom)))
		return (Align)alignment;

	WarningMsg("Bad alignment values\n");
	return (Align)(AL_Top | AL_Left);
}
Align stringToAlignment(const std::string& str)
{
  return str2align(str);
}


static std::string dirName(const std::string& fname)
{
  size_t pos = fname.find_last_of("\\/");
  return (std::string::npos == pos) ? "" : fname.substr(0, pos);
}


void DocTemplate::ReadTemplateFile(const char* a_fileName)
{
	m_items.clear();
	FILE* f = 0;
	fopen_s(&f, a_fileName, "rb");
	if ( f )
	{
		m_currentFile = a_fileName;

		char lineBuf[1024];
		DocTemplateItem currentItem = m_defaults;
    currentItem.m_type = DIT_Unknown;
		bool firstFirst = true;
		bool first = true;
		while ( fgets(lineBuf, sizeof(lineBuf), f) ) {

			m_currentLine++;

			if (lineBuf[0] == '[') {
		
        // First time through here we haven't read anything yet
        if (!firstFirst)
        {
          // new item - this is now after we have read one section and about to start to read a new section
          if (!first) {
            if (currentItem.m_type == DIT_Page)
            {
              m_pageTopLeft.x = currentItem.m_pos.x;
              m_pageTopLeft.y = currentItem.m_pos.y;
              m_pageBottomRight.x = m_pageTopLeft.x + currentItem.m_size.x;
              m_pageBottomRight.y = m_pageTopLeft.y + currentItem.m_size.y;
            }
            else if (currentItem.m_type == DIT_Defaults)
            {
              m_defaults = currentItem;
            }
            else
              m_items.push_back(currentItem);
            currentItem = m_defaults;
            currentItem.m_type = DIT_Unknown;
          }
          first = false;
        }
        firstFirst = false;

				Choose(trim(std::string(lineBuf)))
				{
					OptionLower("[Defaults]")
						currentItem.m_type = DIT_Defaults;
						break;

#define STR_SWITCH_CASE( OPT ) \
					OptionLower("[" #OPT "]") \
						currentItem.m_type = DIT_##OPT; \
						break;
					
					OptionLower("[Text]") // Alias for Label
						currentItem.m_type = DIT_Label;
						break;
					STR_SWITCH_CASE(Label)
					STR_SWITCH_CASE(Page)
					STR_SWITCH_CASE(Background)
					STR_SWITCH_CASE(Image)
					STR_SWITCH_CASE(Line)
					STR_SWITCH_CASE(Box)
					STR_SWITCH_CASE(Circle)
					STR_SWITCH_CASE(Ellipse)
					STR_SWITCH_CASE(Polygon)
					STR_SWITCH_CASE(Spline)
					STR_SWITCH_CASE(Shape)

					Defaults
						currentItem.m_type = DIT_Unknown;
						break;
				}
				Done

			} else {

				std::vector<std::string> strs = split(lineBuf, '=');
				std::string s = (strs.size() > 0) ? trim(strs[0]) : "";
				if (strs.size() != 2)
				{
					if (s != "")
						WarningMsg("Error parsing line, no '=' or line is whitespace.\n");
					continue;
				}

				Choose(s)
				{
					//OptionLower("id")
					//OptionLower("flags")// wrap, ignore, clip

					OptionLower("role")
						currentItem.m_role = stringToTemplateRole(trim(strs[1]));
						break;
					OptionLower("alpha")
						currentItem.m_alpha = str2float(trim(strs[1]));
						break;
					OptionLower("bgColor")
						currentItem.m_bgColor = str2col(trim(strs[1]));
						break;
					OptionLower("align")
						currentItem.m_alignment = str2align(trim(strs[1]));
						break;
					OptionLower("item-align")
						currentItem.m_boundsAlignment = str2align(trim(strs[1]));
						break;
					OptionLower("pos")  // offset
						currentItem.m_pos = str2pos(trim(strs[1]));
						break;
					OptionLower("size")
						currentItem.m_size = str2pos(trim(strs[1]));
						break;
					OptionLower("font")
						currentItem.m_font = trim(strs[1]);
						break;
					OptionLower("fontSize")
						currentItem.m_fontSize = str2float(trim(strs[1]));
						break;
					OptionLower("fillColor")
						currentItem.m_fillColor = str2col(trim(strs[1]));
						break;
					OptionLower("penColor")
						currentItem.m_penColor = str2col(trim(strs[1]));
						break;
					OptionLower("penSize") // alias for penWidth
						currentItem.m_penWidth = str2float(trim(strs[1]));
						break;
					OptionLower("penWidth")
						currentItem.m_penWidth = str2float(trim(strs[1]));
						break;
					OptionLower("penStyle")
						currentItem.m_penStyle = str2style(trim(strs[1]));
						break;
					OptionLower("text")
						currentItem.m_text = trim(strs[1]);
						break;
					OptionLower("points")
						currentItem.m_shape = str2pointList(trim(strs[1]));
						break;
					OptionLower("file")
						currentItem.m_imageFile = trim(strs[1]);
						break;
					OptionLower("cspacing")
						m_columnSpacing = str2float(trim(strs[1]));
						break;
					OptionLower("columns")
						m_columns = stringToInt(trim(strs[1]));
						break;
					Defaults
						if (s != "" && strs.size() != 1)
							currentItem.m_type = DIT_Unknown;
						break;
				}
				Done
			}

			/*
			Image ( pos={0,0} size={w,h} file="image.jpg" )
			Line ( pos={0,0} size={w,h} points={20,20,30,30,40,20} pen={"#000",1.4,"solid"} )
			Shape ( pos={0,0} size={w,h} points={20,20,30,30,40,20} fill="#fff" pen={"#000",1.4,"solid"} )
			//box, circle, ellipse, poly, spline, label, image
			*/
		}
    if (currentItem.m_type == DIT_Page)
    {
      m_pageTopLeft.x = currentItem.m_pos.x;
      m_pageTopLeft.y = currentItem.m_pos.y;
      m_pageBottomRight.x = m_pageTopLeft.x + currentItem.m_size.x;
      m_pageBottomRight.y = m_pageTopLeft.y + currentItem.m_size.y;
    }
    else if (currentItem.m_type == DIT_Defaults)
    {
      m_defaults = currentItem;
    }
    else
      m_items.push_back(currentItem);

    m_items.insert(m_items.begin(), m_defaults);

    fclose(f);
	}
	else
	{
		WarningMsg("Problem opening file : %s\n", a_fileName);
	}
}


void DocTemplate::Save()
{
  WriteTemplateFile(m_currentFile.c_str());
}


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


void DocTemplate::Apply(DocOutputPage& page)
{
	for (size_t i = 0; i < m_items.size(); ++i)
	{
    float x = m_items[i].m_pos.x;
    float y = m_items[i].m_pos.y;

    page.setFontSize(m_items[i].m_fontSize);
    page.setFillColor(m_items[i].m_fillColor);
    page.setPenColor(m_items[i].m_penColor);
    page.setPenWidth(m_items[i].m_penWidth);
    page.setPenStyle(m_items[i].m_penStyle);
    page.setAlpha(m_items[i].m_alpha);

    // TODO: handle special text like [PAGENUM], [PAGECOUNT] etc
		if (m_items[i].m_type == DIT_Label)
		{
      // positioning based on alignment flags
      //      - position based on relative point of the bounds of the text and of the page
      //
      //       eg: the bounds of text have a top,left,right,bottom,hcenter,vcenter values
      //           the screen has same, top,left,right,bottom,hcenter,vcenter values
      //
      //       The positioning is specified as offsets between these
      //       
      //       eg: position the top of the text 5 pixels below the top of the page
      //                        and the left of the text 5 pixels from the left of the page
      //
      //       or, the hcenter of the text at 0 pixels from the hcenter of the page etc.
      //
			
      // Must set the font properties first so that getting the textWidth works correctly
      page.setFontType(FT_Normal);         // TODO: map font name to a font index or make the output accept a string
      
      float pageW = page.width();
      float pageH = page.height();
      Align pageA = m_items[i].m_alignment;
      float pageX = (pageA & AL_Right)  ? pageW : ((pageA & AL_HCenter) ? pageW * 0.5f : 0.0f);
      float pageY = (pageA & AL_Bottom) ? pageH : ((pageA & AL_VCenter) ? pageH * 0.5f : 0.0f);

      float textW = page.textWidth(m_items[i].m_text.c_str());
      float textH = m_items[i].m_fontSize;
      Align textA = m_items[i].m_boundsAlignment;
      float textX = (textA & AL_Right)  ? textW : ((textA & AL_HCenter) ? textW * 0.5f : 0.0f);
      float textY = (textA & AL_Bottom) ? 0 : ((textA & AL_VCenter) ? -textH * 0.5f : -textH);

      x += pageX - textX;
      y += pageY - textY;

			//if (x < 0.0) x = x + page.width();   // negative numbers are aligned from the right
			//if (y < 0.0) y = y + page.height();  // negative numbers are aligned from the bottom
			page.drawText(x, y, m_items[i].m_text.c_str());
		}
		if (m_items[i].m_type == DIT_Polygon)
    {
      page.drawPolygon((float*)m_items[i].m_shape.data(), m_items[i].m_shape.size());
    }
		if (m_items[i].m_type == DIT_Background)
    {
      std::string fileLocation = dirName(m_currentFile) + "/" + m_items[i].m_imageFile;
      if (endsWith(fileLocation, ".svg")) {
        SVGTest(fileLocation.c_str(), 0.02, &page);
      } else {
        // Draws image from top-left corner and stretched to the entire page
        page.drawImage(fileLocation.c_str(), 0, 0, page.width(), page.height());
      }
    }
		if (m_items[i].m_type == DIT_Image)
    {
      std::string fileLocation = dirName(m_currentFile) + "/" + m_items[i].m_imageFile;
      if (endsWith(fileLocation, ".svg")) {
        printf("Looks like an SVG -%s-\n", fileLocation.c_str());
        SVGTest(fileLocation.c_str(), 0.02, &page);
      } else {
        // Draw image at the given position and with the given size
        page.drawImage(fileLocation.c_str(), x, y, m_items[i].m_size.x, m_items[i].m_size.y);
      }
    }
	}

  page.setAlpha(1.0);
}


std::string stringFromAlignment(Align align)
{
  std::string ret;
  if (align & AL_Left)
    ret = "left";
  else if (align & AL_Right)
    ret = "right";
  else
    ret = "center";
  ret += ",";
  if (align & AL_Top)
    ret += "top";
  else if (align & AL_Bottom)
    ret += "bottom";
  else
    ret += "center";
  return ret;
}


std::string stringFromPoint(const Point& pnt)
{
  return stringFromFloat(pnt.x) + "," + stringFromFloat(pnt.y);
}


std::string stringFromPolygon(const std::vector<Point>& poly)
{
  std::string ret;
  bool first = true;
  for (const Point& pnt : poly)
  {
    if (!first)
      ret += ",";
    ret += stringFromPoint(pnt);
    first = false;
  }
  return ret;
}


bool operator==(const Point& pntA, const Point& pntB)
{
  return (pntA.x == pntB.x && pntA.y == pntB.y);
}


bool operator!=(const Point& pntA, const Point& pntB)
{
  return (pntA.x != pntB.x || pntA.y != pntB.y);
}


static void WriteItemToFile(FILE* f, const DocTemplateItem& item, const DocTemplateItem& defaults)
{
  fprintf(f, "[%s]\n", stringFromDocItemType(item.m_type).c_str());

#define OUTPUT_ITEM(member, tag, typ) \
  if (item.m_##member != defaults.m_##member) \
    fprintf(f, tag "=%s\n", stringFrom##typ(item.m_##member).c_str())

  OUTPUT_ITEM(role            , "role",        TemplateRole);
  OUTPUT_ITEM(alpha           , "alpha",       Float    );
  OUTPUT_ITEM(bgColor         , "bgColor",     Color    );
  OUTPUT_ITEM(pos             , "pos",         Point    );
  OUTPUT_ITEM(size            , "size",        Point    );
  OUTPUT_ITEM(font            , "font",        String   );
  OUTPUT_ITEM(fontSize        , "fontSize",    Float    );
  OUTPUT_ITEM(fontColor       , "fontColor",   Color    );
  OUTPUT_ITEM(fillColor       , "fillColor",   Color    );
  OUTPUT_ITEM(penColor        , "penColor",    Color    );
  OUTPUT_ITEM(penWidth        , "penWidth",    Float    );
  OUTPUT_ITEM(penStyle        , "penStyle",    PenStyle );
  OUTPUT_ITEM(alignment       , "align",       Alignment);
  OUTPUT_ITEM(boundsAlignment , "item-align",  Alignment);
  OUTPUT_ITEM(text            , "text",        String   );
  OUTPUT_ITEM(shape           , "points",      Polygon  );

  if (item.m_imageFile != defaults.m_imageFile)
    fprintf(f, "file=%s\n", stringFromString(item.m_imageFile).c_str());

}


void DocTemplate::WriteTemplateFile(const char* a_fileName)
{
	FILE* f = 0;
	fopen_s(&f, a_fileName, "w");
	if ( f )
	{
    // WriteItemToFile(f, m_defaults, m_defaultDefaults);
		// m_currentFile = a_fileName;
    for (const auto& item : m_items)
    {
      if (item.m_type == DIT_Defaults)
        WriteItemToFile(f, item, m_defaultDefaults);
      else
        WriteItemToFile(f, item, m_defaults);
      fprintf(f, "\n");
    }

    DocTemplateItem pageItem;
    pageItem = m_defaults;
    pageItem.m_type = DIT_Page;
    pageItem.m_pos = m_pageTopLeft;
    pageItem.m_size.x = m_pageBottomRight.x - m_pageTopLeft.x;
    pageItem.m_size.y = m_pageBottomRight.y - m_pageTopLeft.y;
    WriteItemToFile(f, pageItem, m_defaults);
    fprintf(f, "columns=%s\n", stringFromInt(m_columns).c_str());
    fprintf(f, "cspacing=%s\n", stringFromFloat(m_columnSpacing).c_str());
    fprintf(f, "\n");

    fclose(f);
  }
}