// character_manager.cpp: implementation of the TFont class.
//
//////////////////////////////////////////////////////////////////////

#include "tpixelgr.h"
#include "tfont.h"
#include "tstroke.h"
//#include "tcurves.h"
#include "traster.h"
#include <vector>
#include <iostream>
#include <string>
//#include <tstring.h>
#include <tmathutil.h>
//#include <tdebugmessage.h>
#include "tvectorimage.h"
using namespace std;

//=============================================================================

typedef map<wstring, LOGFONTW> WindowsFontTable;
typedef map<pair<unsigned short, unsigned short>, int> KerningPairs;

//=============================================================================

struct TFont::Impl {
  bool m_hasKerning;
  bool m_hasVertical;
  HFONT m_font;
  HDC m_hdc;
  TEXTMETRICW m_metrics;
  KerningPairs m_kerningPairs;

  Impl(const LOGFONTW &font, HDC hdc);
  ~Impl();
};

//-----------------------------------------------------------------------------

TFont::TFont(const LOGFONTW &font, HDC hdc) { m_pimpl = new Impl(font, hdc); }

//-----------------------------------------------------------------------------

TFont::~TFont() { delete m_pimpl; }

//-----------------------------------------------------------------------------

TFont::Impl::Impl(const LOGFONTW &logfont, HDC hdc) : m_hdc(hdc) {
  m_font = CreateFontIndirectW(&logfont);

  if (!m_font) throw TFontCreationError();

  HGDIOBJ hObj = SelectObject(hdc, m_font);
  if (!hObj || hObj == HGDI_ERROR) throw TFontCreationError();

  if (!GetTextMetricsW(hdc, &m_metrics)) throw TFontCreationError();

  DWORD pairsCount = GetKerningPairsW(hdc, 0, 0);
  if (pairsCount) {
    m_hasKerning = true;
    std::unique_ptr<KERNINGPAIR[]> tempKernPairs(new KERNINGPAIR[pairsCount]);
    GetKerningPairsW(hdc, pairsCount, tempKernPairs.get());
    for (UINT i = 0; i < pairsCount; i++) {
      pair<unsigned short, unsigned short> key =
          make_pair(tempKernPairs[i].wFirst, tempKernPairs[i].wSecond);
      m_kerningPairs[key] = tempKernPairs[i].iKernAmount;
    }
  } else
    m_hasKerning = false;

  m_hasVertical = (logfont.lfFaceName)[0] == '@';
}

//-----------------------------------------------------------------------------

TFont::Impl::~Impl() {
  // delete m_advances;
  DeleteObject(m_font);
}

//-----------------------------------------------------------------------------

namespace {
inline TThickPoint toThickPoint(POINTFX point) {
  double app1 = point.x.value +
                ((double)point.x.fract) / (std::numeric_limits<WORD>::max)();
  double app2 = point.y.value +
                ((double)point.y.fract) / (std::numeric_limits<WORD>::max)();
  return TThickPoint(app1, app2, 0);
}
}

//-----------------------------------------------------------------------------

TPoint TFont::drawChar(TVectorImageP &image, wchar_t charcode,
                       wchar_t nextCharCode) const

{
  GLYPHMETRICS gm;
  MAT2 mat2;
  mat2.eM11.fract = 0;
  mat2.eM12.fract = 0;
  mat2.eM21.fract = 0;
  mat2.eM22.fract = 0;
  mat2.eM11.value = 1;
  mat2.eM12.value = 0;
  mat2.eM21.value = 0;
  mat2.eM22.value = 1;

  vector<TThickPoint> points;

  UINT j = 0;

  DWORD charMemorySize =
      GetGlyphOutlineW(m_pimpl->m_hdc, charcode, GGO_NATIVE, &gm, 0, 0, &mat2);
  if (charMemorySize == GDI_ERROR) {
    assert(0);
    return TPoint();
  }

  std::unique_ptr<char[]> lpvBuffer(new char[charMemorySize]);

  charMemorySize = GetGlyphOutlineW(m_pimpl->m_hdc, charcode, GGO_NATIVE, &gm,
                                    charMemorySize, lpvBuffer.get(), &mat2);
  if (charMemorySize == GDI_ERROR) {
    assert(0);
    return TPoint();
  }

  TTPOLYGONHEADER *header = (TTPOLYGONHEADER *)lpvBuffer.get();

  while ((char *)header < (char *)lpvBuffer.get() + charMemorySize) {
    points.clear();
    TThickPoint startPoint = toThickPoint(header->pfxStart);
    points.push_back(startPoint);

    if (header->dwType != TT_POLYGON_TYPE) {
      assert(0);
    }
    int memorySize = header->cb;

    TTPOLYCURVE *curve = (TTPOLYCURVE *)(header + 1);

    while ((char *)curve < (char *)header + memorySize) {
      switch (curve->wType) {
      case TT_PRIM_LINE:

        for (j = 0; j < curve->cpfx; j++) {
          TThickPoint p0 = points.back();
          TThickPoint p1 = toThickPoint(((*curve).apfx[j]));
          points.push_back((p0 + p1) * 0.5);
          points.push_back(p1);
        }

        break;

      case TT_PRIM_QSPLINE:

        for (j = 0; (int)j + 2 < curve->cpfx; j++) {
          TThickPoint p1 = toThickPoint(((*curve).apfx[j]));
          TThickPoint p2 = toThickPoint(((*curve).apfx[j + 1]));

          points.push_back(p1);
          points.push_back((p1 + p2) * 0.5);
        }
        points.push_back(toThickPoint(((*curve).apfx[j++])));
        points.push_back(toThickPoint(((*curve).apfx[j++])));

        break;
      case TT_PRIM_CSPLINE:
        assert(0);
        break;
      default:
        assert(0);
      }

      curve = (TTPOLYCURVE *)(&(curve->apfx)[j]);
    }

    TThickPoint p0 = points.back();
    if (!isAlmostZero(p0.x - startPoint.x) ||
        !isAlmostZero(p0.y - startPoint.y)) {
      points.push_back((p0 + startPoint) * 0.5);
      points.push_back(startPoint);
    }

    TStroke *stroke = new TStroke();
    stroke->reshape(&(points[0]), points.size());
    stroke->setSelfLoop(true);
    image->addStroke(stroke);

    header = (TTPOLYGONHEADER *)curve;
  }

  image->group(0, image->getStrokeCount());

  return getDistance(charcode, nextCharCode);
}

//-----------------------------------------------------------------------------

namespace {

TPoint appDrawChar(TRasterGR8P &outImage, HDC hdc, wchar_t charcode) {
  GLYPHMETRICS gm;
  MAT2 mat2;
  mat2.eM11.fract = 0;
  mat2.eM12.fract = 0;
  mat2.eM21.fract = 0;
  mat2.eM22.fract = 0;
  mat2.eM11.value = 1;
  mat2.eM12.value = 0;
  mat2.eM21.value = 0;
  mat2.eM22.value = 1;

  DWORD charMemorySize =
      GetGlyphOutlineW(hdc, charcode, GGO_GRAY8_BITMAP, &gm, 0, 0, &mat2);

  if (charMemorySize == GDI_ERROR) {
    assert(0);
  }

  int lx = gm.gmBlackBoxX;
  int ly = gm.gmBlackBoxY;

  int wrap = ((lx + 3) >> 2) << 2;

  TRasterGR8P appImage = TRasterGR8P(wrap, ly);
  appImage->clear();
  outImage = appImage->extract(0, 0, lx - 1, ly - 1);
  outImage->lock();
  GetGlyphOutlineW(hdc, charcode, GGO_GRAY8_BITMAP, &gm, wrap * ly,
                   outImage->getRawData(), &mat2);
  outImage->unlock();
  TPoint glyphOrig;
  glyphOrig.x = gm.gmptGlyphOrigin.x;
  glyphOrig.y = gm.gmptGlyphOrigin.y;
  return glyphOrig;
}
}

//-----------------------------------------------------------------------------
// valori compresi tra 0 e 64 (si si, proprio 64 e non 63: sono 65 valori)

TPoint TFont::drawChar(TRasterGR8P &outImage, TPoint &glyphOrigin,
                       wchar_t charcode, wchar_t nextCharCode) const {
  TRasterGR8P grayAppImage;

  TPoint glyphOrig = appDrawChar(grayAppImage, m_pimpl->m_hdc, charcode);

  if (glyphOrig.x < 0) {
    glyphOrigin.x = glyphOrig.x;
    glyphOrig.x   = 0;
  } else
    glyphOrigin.x = 0;

  if (glyphOrig.y < 0) {
    glyphOrigin.y = glyphOrig.y;
    glyphOrig.y   = 0;
  } else
    glyphOrigin.y = 0;

  int srcLx = grayAppImage->getLx();
  int srcLy = grayAppImage->getLy();

  int dstLx = srcLx + glyphOrig.x;
  int dstLy = getMaxHeight();

  outImage = TRasterGR8P(dstLx, dstLy);
  outImage->clear();

  int ty = m_pimpl->m_metrics.tmDescent - 1 + glyphOrig.y;
  assert(ty < dstLy);
  assert(ty >= srcLy - 1);
  grayAppImage->lock();
  outImage->lock();

  for (int sy = 0; sy < srcLy; ++sy, --ty) {
    TPixelGR8 *srcPix = grayAppImage->pixels(sy);
    TPixelGR8 *tarPix = outImage->pixels(ty) + glyphOrig.x;
    for (int x = 0; x < srcLx; ++x) {
      assert(srcPix->value < 65);

      switch (srcPix->value) {
      case 0:
        tarPix->value = 0;
        break;
      default:
        tarPix->value = (srcPix->value << 2) - 1;
        break;
      }
      ++srcPix;
      ++tarPix;
    }
  }
  grayAppImage->unlock();
  outImage->unlock();

  return getDistance(charcode, nextCharCode);
}

//-----------------------------------------------------------------------------

TPoint TFont::drawChar(TRasterCM32P &outImage, TPoint &glyphOrigin, int inkId,
                       wchar_t charcode, wchar_t nextCharCode) const {
  TRasterGR8P grayAppImage;
  TPoint glyphOrig = appDrawChar(grayAppImage, m_pimpl->m_hdc, charcode);

  if (glyphOrig.x < 0) {
    glyphOrigin.x = glyphOrig.x;
    glyphOrig.x   = 0;
  } else
    glyphOrigin.x = 0;

  if (glyphOrig.y < 0) {
    glyphOrigin.y = glyphOrig.y;
    glyphOrig.y   = 0;
  } else
    glyphOrigin.y = 0;

  int srcLx = grayAppImage->getLx();
  int srcLy = grayAppImage->getLy();

  int dstLx = srcLx + glyphOrig.x;
  int dstLy = getMaxHeight();

  outImage = TRasterCM32P(dstLx, dstLy);
  outImage->clear();

  assert(TPixelCM32::getMaxTone() == 255);
  // TPixelCM32
  // bgColor(BackgroundStyle,BackgroundStyle,TPixelCM32::getMaxTone());
  TPixelCM32 bgColor;

  int ty = m_pimpl->m_metrics.tmDescent - 1 + glyphOrig.y;
  assert(ty < dstLy);
  assert(ty >= srcLy - 1);
  grayAppImage->lock();
  outImage->lock();

  for (int sy = 0; sy < srcLy; ++sy, --ty) {
    TPixelGR8 *srcPix  = grayAppImage->pixels(sy);
    TPixelCM32 *tarPix = outImage->pixels(ty) + glyphOrig.x;
    for (int x = 0; x < srcLx; ++x) {
      int tone = 256 - (srcPix->value << 2);

      // grayScale  ToonzImage tone   Meaning
      //         0  255               Bg = PurePaint
      //         1  252
      //                 ...
      //        63    4
      //        64    0               Fg = Pure Ink

      if (tone < 0) tone = 0;

      if (tone >= 255)
        *tarPix = bgColor;
      else
        *tarPix = TPixelCM32(inkId, 0, tone);  // BackgroundStyle,tone);

      ++srcPix;
      ++tarPix;
    }
  }
  grayAppImage->unlock();
  outImage->unlock();

  return getDistance(charcode, nextCharCode);
}

//-----------------------------------------------------------------------------

TPoint TFont::getDistance(wchar_t firstChar, wchar_t secondChar) const {
  int advance;
  BOOL result = GetCharWidth32W(m_pimpl->m_hdc, firstChar, firstChar, &advance);
  assert(result);
  if (m_pimpl->m_hasKerning && secondChar) {
    KerningPairs::iterator it =
        m_pimpl->m_kerningPairs.find(make_pair(firstChar, secondChar));
    if (it != m_pimpl->m_kerningPairs.end()) {
      advance += it->second;
    }
  }
  return TPoint(advance, 0);
}

//-----------------------------------------------------------------------------

int TFont::getMaxHeight() const { return m_pimpl->m_metrics.tmHeight; }

//-----------------------------------------------------------------------------

int TFont::getMaxWidth() const { return m_pimpl->m_metrics.tmMaxCharWidth; }
//-----------------------------------------------------------------------------

int TFont::getLineAscender() const { return m_pimpl->m_metrics.tmAscent; }

//-----------------------------------------------------------------------------

int TFont::getLineDescender() const { return -m_pimpl->m_metrics.tmDescent; }

//-----------------------------------------------------------------------------

bool TFont::hasKerning() const { return m_pimpl->m_hasKerning; }

//-----------------------------------------------------------------------------

bool TFont::hasVertical() const { return m_pimpl->m_hasVertical; }

//=============================================================================
//====================      TFontManager  =====================================
//=============================================================================

//---------------------------------------------------------

struct TFontManager::Impl {
  WindowsFontTable m_families;
  bool m_loaded;

  LOGFONTW m_currentLogFont;
  TFont *m_currentFont;

  // this option is set by library user when he wants to write vertically.
  // In this implementation, if m_vertical is true and the font
  // has the @-version, the library use it.
  bool m_vertical;

  TFontManager::Impl() : m_loaded(false), m_currentFont(0), m_vertical(false) {}
};

//---------------------------------------------------------

TFontManager::TFontManager() { m_pimpl = new TFontManager::Impl(); }

//---------------------------------------------------------

TFontManager::~TFontManager() { delete m_pimpl; }

//---------------------------------------------------------

TFontManager *TFontManager::instance() {
  static TFontManager theManager;
  return &theManager;
}

//---------------------------------------------------------

namespace {
BOOL CALLBACK EnumFamCallBack(CONST LOGFONTW *lplf, CONST TEXTMETRICW *,
                              DWORD FontType, LPARAM data) {
  if (FontType & TRUETYPE_FONTTYPE) {
    LOGFONTW newLplf        = *lplf;
    newLplf.lfHeight        = 200;
    newLplf.lfWidth         = 0;
    WindowsFontTable &table = *(WindowsFontTable *)data;
    table[lplf->lfFaceName] = newLplf;
    return TRUE;
  }
  return TRUE;
}
}

//---------------------------------------------------------

void TFontManager::loadFontNames() {
  if (m_pimpl->m_loaded) return;

  HDC hdc = CreateCompatibleDC(NULL);
  if (!hdc) throw TFontLibraryLoadingError();
  EnumFontFamiliesW(hdc, (LPCWSTR)NULL, (FONTENUMPROCW)EnumFamCallBack,
                    (LPARAM) & (m_pimpl->m_families));
  DeleteDC(hdc);
  hdc = 0;
  if (m_pimpl->m_families.empty()) throw TFontLibraryLoadingError();

  m_pimpl->m_loaded = true;
}

//---------------------------------------------------------

void TFontManager::setFamily(const wstring family) {
  wstring userFamilyName =
      ((family.c_str())[0] == L'@') ? wstring(family.c_str() + 1) : family;
  wstring realFamilyName = (m_pimpl->m_vertical && (family.c_str())[0] != L'@')
                               ? L"@" + family
                               : family;

  wstring currentFamilyName = wstring(m_pimpl->m_currentLogFont.lfFaceName);

  if (currentFamilyName == realFamilyName) return;

  LOGFONTW logfont;
  if (m_pimpl->m_vertical) {
    WindowsFontTable::iterator it = m_pimpl->m_families.find(realFamilyName);
    if (it != m_pimpl->m_families.end())
      logfont = it->second;
    else {
      it = m_pimpl->m_families.find(userFamilyName);
      assert(it != m_pimpl->m_families.end());
      if (it != m_pimpl->m_families.end())
        logfont = it->second;
      else
        throw TFontCreationError();
    }
  } else {
    WindowsFontTable::iterator it = m_pimpl->m_families.find(userFamilyName);
    assert(it != m_pimpl->m_families.end());
    if (it != m_pimpl->m_families.end())
      logfont = it->second;
    else
      throw TFontCreationError();
  }

  if (m_pimpl->m_currentFont) {
    logfont.lfHeight = m_pimpl->m_currentLogFont.lfHeight;
    logfont.lfItalic = m_pimpl->m_currentLogFont.lfItalic;
    logfont.lfWeight = m_pimpl->m_currentLogFont.lfWeight;
  } else
    logfont.lfHeight = 200;

  try {
    HDC hdc        = CreateCompatibleDC(NULL);
    TFont *newfont = new TFont(logfont, hdc);
    delete m_pimpl->m_currentFont;
    m_pimpl->m_currentFont    = newfont;
    m_pimpl->m_currentLogFont = logfont;
  } catch (TException &) {
    throw TFontCreationError();
  }
}

//---------------------------------------------------------

void TFontManager::setTypeface(const wstring typeface) {
  LOGFONTW logfont = m_pimpl->m_currentLogFont;
  logfont.lfItalic =
      (typeface == L"Italic" || typeface == L"Bold Italic") ? TRUE : FALSE;
  logfont.lfWeight =
      (typeface == L"Bold" || typeface == L"Bold Italic") ? 700 : 400;

  try {
    HDC hdc        = CreateCompatibleDC(NULL);
    TFont *newfont = new TFont(logfont, hdc);
    delete m_pimpl->m_currentFont;
    m_pimpl->m_currentFont    = newfont;
    m_pimpl->m_currentLogFont = logfont;
  } catch (TException &) {
    throw TFontCreationError();
  }
}

//---------------------------------------------------------

void TFontManager::setSize(int size) {
  LOGFONTW logfont = m_pimpl->m_currentLogFont;
  logfont.lfHeight = size;
  try {
    HDC hdc        = CreateCompatibleDC(NULL);
    TFont *newfont = new TFont(logfont, hdc);
    delete m_pimpl->m_currentFont;
    m_pimpl->m_currentFont    = newfont;
    m_pimpl->m_currentLogFont = logfont;
  } catch (TException &) {
    throw TFontCreationError();
  }
}

//---------------------------------------------------------

wstring TFontManager::getCurrentFamily() const {
  wstring currentFamilyName =
      (m_pimpl->m_currentLogFont.lfFaceName[0] == L'@')
          ? wstring(m_pimpl->m_currentLogFont.lfFaceName + 1)
          : wstring(m_pimpl->m_currentLogFont.lfFaceName);
  return currentFamilyName;
}

//---------------------------------------------------------

wstring TFontManager::getCurrentTypeface() const {
  if (m_pimpl->m_currentLogFont.lfItalic) {
    if (m_pimpl->m_currentLogFont.lfWeight == 700)
      return L"Bold Italic";
    else
      return L"Italic";
  } else {
    if (m_pimpl->m_currentLogFont.lfWeight == 700)
      return L"Bold";
    else
      return L"Regular";
  }
}

//---------------------------------------------------------

TFont *TFontManager::getCurrentFont() {
  if (m_pimpl->m_currentFont) return m_pimpl->m_currentFont;

  if (!m_pimpl->m_currentFont) loadFontNames();

  assert(!m_pimpl->m_families.empty());
  setFamily(m_pimpl->m_families.begin()->first);

  return m_pimpl->m_currentFont;
}

//---------------------------------------------------------

void TFontManager::getAllFamilies(vector<wstring> &families) const {
  families.clear();
  families.reserve(m_pimpl->m_families.size());
  WindowsFontTable::iterator it = m_pimpl->m_families.begin();
  for (; it != m_pimpl->m_families.end(); ++it) {
    if ((it->first)[0] != L'@') families.push_back(it->first);
  }
}

//---------------------------------------------------------

void TFontManager::getAllTypefaces(vector<wstring> &typefaces) const {
  typefaces.resize(4);
  typefaces[0] = L"Regular";
  typefaces[1] = L"Italic";
  typefaces[2] = L"Bold";
  typefaces[3] = L"Bold Italic";
}

//---------------------------------------------------------

void TFontManager::setVertical(bool vertical) {
  if (m_pimpl->m_vertical == vertical) return;
  m_pimpl->m_vertical = vertical;

  wstring currentFamilyName =
      (m_pimpl->m_currentLogFont.lfFaceName[0] == L'@')
          ? wstring(m_pimpl->m_currentLogFont.lfFaceName + 1)
          : wstring(m_pimpl->m_currentLogFont.lfFaceName);
  if (vertical) currentFamilyName = L'@' + currentFamilyName;
  setFamily(currentFamilyName);
}