#include "thumbnailviewer.h"
#include "thumbnail.h"
#include "tfilepath.h"
#include "tsystem.h"

#include "tw/textfield.h"
#include "tw/colors.h"
#include "tw/event.h"
#include "tw/dragdrop.h"
#include "tw/keycodes.h"
#include "tw/mainshell.h"

#include "tw/message.h"

using namespace TwConsts;

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

class ThumbnailViewer::NameField : public TTextField {
  Thumbnail *m_thumbnail;

public:
  NameField(TWidget *parent) : TTextField(parent), m_thumbnail(0) {}
  void onFocusChange(bool on) {
    if (!on) close();
  }

  void close() {
    if (m_thumbnail) {
      try {
        m_thumbnail->setName(toString(getText()));
      } catch (...) {
        TMessage::error("unable to change name");
      }
    }
    hide();
  }

  void keyDown(int key, unsigned long flags, const TPoint &p) {
    if (key == TK_Return)
      close();
    else
      TTextField::keyDown(key, flags, p);
  }

  void setThumbnail(Thumbnail *thumbnail) {
    m_thumbnail = thumbnail;
    setText(m_thumbnail->getName());
    selectAll();
  }
};

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

ThumbnailViewer::ThumbnailViewer(TWidget *parent, string name)
    : TScrollView(parent, name)
    , m_selectedItemIndex(-1)
    , m_itemSize(94, 100)
    , m_itemSpace(10, 10)
    , m_margins(10, 10)
    , m_playButtonBox(TPoint(85, 2), TDimension(10, 10))
    , m_iconBox(TPoint(2 + 4 - 3, 20 + 4), TDimension(96 - 8, 78 - 8))
    , m_textBox(TPoint(2 + 4 + 2 + 10, 2 + 2), TDimension(65, 18))
    , m_flag(false)
    , m_playing(false)
    , m_loading(false)
    , m_timerActive(false)
    , m_dragDropArmed(false)
    , m_oldPos(0, 0) {
  setBackgroundColor(White);
  m_nameField = new NameField(this);
  m_nameField->hide();
}

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

ThumbnailViewer::~ThumbnailViewer() { clearPointerContainer(m_items); }

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

int ThumbnailViewer::getColumnCount() const {
  int columnWidth    = m_itemSize.lx + m_itemSpace.lx;
  int availableWidth = getLx() - m_margins.lx * 2 + m_itemSpace.lx;
  return tmax(1, (availableWidth) / columnWidth);
}

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

TPoint ThumbnailViewer::getItemPos(int index) {
  int columnCount = getColumnCount();
  int row         = index / columnCount;
  int col         = index % columnCount;
  int x           = m_margins.lx + col * (m_itemSize.lx + m_itemSpace.lx);
  int y           = getLy() - m_margins.ly - m_itemSize.ly -
          row * (m_itemSize.ly + m_itemSpace.ly);
  return TPoint(x, y);
}

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

TRect ThumbnailViewer::getItemBounds(int index) {
  return TRect(getItemPos(index), m_itemSize);
}

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

int ThumbnailViewer::findItem(const TPoint &pos) {
  int columnCount = getColumnCount();
  int col         = (pos.x - m_margins.lx) / (m_itemSize.lx + m_itemSpace.lx);
  int row         = (getLy() - m_margins.ly - m_itemSpace.ly - pos.y) /
            (m_itemSize.ly + m_itemSpace.ly);
  int index = row * columnCount + col;
  if (0 <= index && index < (int)m_items.size() &&
      getItemBounds(index).contains(pos))
    return index;
  else
    return -1;
}

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

int ThumbnailViewer::getItemCount() const { return m_items.size(); }

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

Thumbnail *ThumbnailViewer::getItem(int index) const {
  assert(0 <= index && index < (int)m_items.size());
  return m_items[index];
}

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

void ThumbnailViewer::configureNotify(const TDimension &d) {
  TScrollView::configureNotify(d);
  // m_nameField->setGeometry(TPoint(10,10), TDimension(100,30));
  updateContentSize();
  invalidate();
}

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

void ThumbnailViewer::drawFrame(int index) {
  TPoint base = getItemPos(index);
  assert(0 <= index && index < (int)m_items.size());
  assert(m_items[index]->getRaster());
  assert(m_iconBox.getSize() == m_items[index]->getRaster()->getSize());
  rectwrite(m_items[index]->getRaster(), base + m_iconBox.getP00());
}

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

void ThumbnailViewer::drawItem(int index) {
  TPoint base = getItemPos(index);
  if (index < 0 || index >= (int)m_items.size()) {
    setColor(getBackgroundColor());
    fillRect(TRect(base, m_itemSize));
    return;
  }

  // setColor(Black);
  // fillRect(TRect(base, m_itemSize));

  Thumbnail *item = m_items[index];
  bool selected   = item != 0 && index == m_selectedItemIndex;

  TRect r0(base, m_itemSize);
  TRect r1 = m_iconBox + base;
  TRect r2 = m_textBox + base;

  setColor(selected ? Cyan : getBackgroundColor());
  fillRect(r0.x0, r1.y0, r1.x0 - 1, r1.y1);  // sinistra
  fillRect(r1.x1 + 1, r1.y0, r0.x1, r1.y1);  // destra
  fillRect(r0.x0, r0.y0, r0.x1, r1.y0 - 1);  // sotto
  // fillRect(r1.x0,r1.y1+1,r1.x1,r0.y1); // sopra
  TRect topLine(r0.x0, r1.y1 + 1, r0.x1, r0.y1);
  TRect sceneLine = topLine;
  sceneLine.y0    = sceneLine.y1 - 3;
  topLine.y1      = sceneLine.y0 - 1;
  fillRect(topLine);

  if (item->getType() == Thumbnail::SCENE) {
    setColor(Black);
    drawRect(sceneLine);
    setColor(White);
    fillRect(sceneLine.enlarge(-1));
    int x;
    setColor(Black);
    for (x = sceneLine.x0 + 5; x + 5 < sceneLine.x1; x += 10) {
      int y = sceneLine.y0 + 1;
      drawLine(x, y, x + 4, y);
      y++;
      x++;
      drawLine(x, y, x + 4, y);
    }
  } else {
    setColor(White);
    fillRect(sceneLine);
  }

  string name   = item->getName();
  int maxWidth  = r2.getLx() - 4;
  TDimension ts = getTextSize(name);
  if (ts.lx > maxWidth) {
    do {
      name.pop_back();
      ts = getTextSize(name);
    } while (name.size() > 1 && ts.lx > maxWidth);
  }

  TPoint textOrigin = r2.getP00() + TPoint(2 - 10, (r2.getLy() - ts.ly) / 2);

  setColor(Black);
  string fname          = name;
  string type           = item->getPath().getType();
  if (type != "") fname = fname + "." + type;

  fname = item->getPath().getLevelName();
  drawText(textOrigin, fname);

  if (selected) {
    TRect r = m_playButtonBox + base;
    setColor(Blue);
    if (m_playing) {
      int x0 = r.x0, x3 = r.x1;
      int x1 = (x0 + x3) / 2 - 1;
      int x2 = x3 - (x1 - x0);
      drawRect(x0, r.y0, x1, r.y1);
      drawRect(x2, r.y0, x3, r.y1);
    } else {
      vector<TPoint> pts;
      int d = (r.y1 - r.y0 + 1) / 2;
      int x = r.x0;
      int y = r.y0;
      pts.push_back(TPoint(x, y));
      pts.push_back(TPoint(x + d, y + d));
      pts.push_back(TPoint(x, y + d * 2));
      fillPolygon(Cyan, Blue, &pts[0], 3);
    }
  }
  assert(0 <= index && index < (int)m_items.size());
  assert(m_items[index]->getRaster());
  assert(m_iconBox.getSize() == m_items[index]->getRaster()->getSize());
  rectwrite(m_items[index]->getRaster(), base + m_iconBox.getP00());
}

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

void ThumbnailViewer::drawBackground() {
  int itemCount   = m_items.size();
  int columnCount = getColumnCount();
  int rowCount    = (itemCount + columnCount - 1) / columnCount;

  TRect clipRect;
  getClipRect(clipRect);  // coordinate window
  clipRect -= TPoint(m_xoff, m_yoff);
  TRect rect;
  rect.x0 = m_margins.lx;
  rect.x1 = m_margins.lx + (m_itemSize.lx + m_itemSpace.lx) * columnCount -
            m_itemSpace.lx - 1;
  rect.y1 = getLy() - m_margins.ly - 1;
  rect.y0 = rect.y1 - (m_itemSize.ly + m_itemSpace.ly) * rowCount +
            m_itemSpace.ly + 1;

  setColor(getBackgroundColor());

  // alto
  if (rect.y1 + 1 <= clipRect.y1)
    fillRect(clipRect.x0, rect.y1 + 1, clipRect.x1, clipRect.y1);

  // basso
  if (clipRect.y0 <= rect.y0 - 1)
    fillRect(clipRect.x0, clipRect.y0, clipRect.x1, rect.y0 - 1);

  int y0 = tmax(clipRect.y0, rect.y0);
  int y1 = tmin(clipRect.y1, rect.y1);
  if (y0 <= y1) {
    // sinistra
    if (clipRect.x0 <= rect.x0 - 1) fillRect(clipRect.x0, y0, rect.x0 - 1, y1);

    // destra
    if (rect.x1 + 1 <= clipRect.x1) fillRect(rect.x1 + 1, y0, clipRect.x1, y1);
  }

  // interlinee verticali
  for (int r = 0; r < rowCount; r++) {
    int y1 = rect.y1 - (m_itemSize.ly + m_itemSpace.ly) * r + m_itemSpace.ly;
    int y0 = y1 - m_itemSpace.ly + 1;
    fillRect(clipRect.x0, y0, clipRect.x1, y1);
  }
  for (int c = 0; c < columnCount - 1; c++) {
    int x0 =
        m_margins.lx + (m_itemSize.lx + m_itemSpace.lx) * c + m_itemSize.lx;
    int x1 = x0 + m_itemSpace.lx - 1;
    fillRect(x0, clipRect.y0, x1, clipRect.y1);
  }

  // ultima riga
  c = itemCount % columnCount;
  if (c != 0) {
    TRect box = getItemBounds(itemCount - 1);
    if (box.y0 <= clipRect.y1 && box.y1 >= clipRect.y0 &&
        box.x1 + 1 <= clipRect.x1)
      fillRect(box.x1 + 1, box.y0, clipRect.x1, box.y1);
  }
}

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

void ThumbnailViewer::repaint() {
  if (m_flag) {
    if (m_selectedItemIndex) drawFrame(m_selectedItemIndex);
  } else {
    // m_loadingDirectory = false;
    // setColor(Black);
    // fillRect(getBounds());

    drawBackground();

    TRect clipRect;
    getClipRect(clipRect);  // coordinate window
    clipRect -= TPoint(m_xoff, m_yoff);

    bool loading = false;
    for (int i = 0; i < (int)m_items.size(); i++) {
      TRect bounds = getItemBounds(i);
      if (bounds.overlaps(clipRect)) {
        drawItem(i);
        if (m_items[i]->isIconLoaded() == false) loading = true;
      }
    }
    if (loading) {
      m_loading = true;
      if (!m_timerActive) {
        m_timerActive = true;
        startTimer(200);
      }
    }
  }
}

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

void ThumbnailViewer::select(int index) {
  assert(index == -1 || 0 <= index && index < (int)m_items.size());
  m_playing = false;
  if (m_timerActive) {
    m_timerActive = false;
    stopTimer();
  }
  Thumbnail *thumbnail;
  if (m_selectedItemIndex >= 0) {
    thumbnail = m_items[m_selectedItemIndex];
    thumbnail->setPlaying(false);
  }
  m_selectedItemIndex = index;
  onSelect(m_selectedItemIndex);
}

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

void ThumbnailViewer::startPlaying() {
  if (m_playing) return;
  if (m_selectedItemIndex < 0) return;
  m_playing = true;
  assert(0 <= m_selectedItemIndex && m_selectedItemIndex < (int)m_items.size());
  m_items[m_selectedItemIndex]->setPlaying(true);
  if (!m_timerActive) {
    m_timerActive = true;
    startTimer(200);
  }
}

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

void ThumbnailViewer::stopPlaying() {
  if (!m_playing) return;
  m_playing = false;
  if (m_selectedItemIndex >= 0) {
    assert(0 <= m_selectedItemIndex &&
           m_selectedItemIndex < (int)m_items.size());
    m_items[m_selectedItemIndex]->gotoFrame(0);
    m_items[m_selectedItemIndex]->setPlaying(false);
  }
  if (m_timerActive) {
    m_timerActive = false;
    stopTimer();
  }
}

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

void ThumbnailViewer::leftButtonDown(const TMouseEvent &e) {
  TPoint pos      = e.m_pos - TPoint(m_xoff, m_yoff);
  m_oldPos        = e.m_pos;
  m_dragDropArmed = false;

  m_nameField->hide();
  //  if(setGeometry(m_textBox + bounds.getP00());
  //           m_nameField->setText(m_items[index]->getName());
  //           m_nameField->show();

  int index = findItem(pos);
  if (index >= 0) {
    if (m_selectedItemIndex == index) {
      TRect bounds = getItemBounds(index);
      pos -= bounds.getP00();
      if (m_playButtonBox.contains(pos)) {
        if (!m_playing)
          startPlaying();
        else
          stopPlaying();
        invalidate();
      } else if (m_textBox.contains(pos)) {
        stopPlaying();
        m_nameField->setGeometry(m_textBox + bounds.getP00() + TPoint(-10, 0));
        m_nameField->setThumbnail(m_items[index]);
        m_nameField->show();
        setFocusOwner(m_nameField);
      } else {
        m_dragDropArmed = true;
      }
    } else {
      select(index);
      m_dragDropArmed = true;
    }
  } else
    select(-1);
  invalidate();
}

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

void ThumbnailViewer::leftButtonDrag(const TMouseEvent &e) {
  if (!m_dragDropArmed || m_selectedItemIndex < 0) return;
  if (norm2(e.m_pos - m_oldPos) < 100) return;
  m_dragDropArmed = false;

  Thumbnail *item = m_items[m_selectedItemIndex];
  TFilePath path  = item->getPath();
  if (path.getWideString() != toWideString("")) {
    TDropSource dropSource;
    std::vector<std::string> v;
    v.push_back(toString(path.getWideString()));
    TDataObject data(v);
    dropSource.doDragDrop(data);
  }
}

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

void ThumbnailViewer::leftButtonUp(const TMouseEvent &e) {
  m_dragDropArmed = false;
}

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

void ThumbnailViewer::leftButtonDoubleClick(const TMouseEvent &e) {
  TPoint pos = e.m_pos - TPoint(m_xoff, m_yoff);
  m_nameField->hide();
  int index = findItem(pos);
  if (index >= 0) onDoubleClick(index);
}

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

void ThumbnailViewer::onTimer(int) {
  stopTimer();
  m_timerActive = false;
  if (m_playing && m_selectedItemIndex >= 0) {
    Thumbnail *thumbnail = m_items[m_selectedItemIndex];
    bool ret             = thumbnail->nextFrame();
    if (ret) {
      m_timerActive = true;
      startTimer(100);
    } else {
      thumbnail->gotoFrame(0);
      thumbnail->setPlaying(false);
      m_playing = false;
    }
    invalidate();
  } else if (m_loading) {
    for (int i = 0; i < (int)m_items.size(); i++)
      if (!m_items[i]->isIconLoaded()) {
        m_items[i]->loadIcon();
        invalidate();
        return;
      }
  }
}

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

void ThumbnailViewer::addItem(Thumbnail *item) { m_items.push_back(item); }

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

void ThumbnailViewer::removeItem(Thumbnail *item) {
  std::vector<Thumbnail *>::iterator it =
      std::find(m_items.begin(), m_items.end(), item);
  if (it != m_items.end()) m_items.erase(it);

  m_selectedItemIndex = -1;
}

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

void ThumbnailViewer::clearItems() {
  clearPointerContainer(m_items);
  m_selectedItemIndex = -1;
  m_playing           = false;
  m_loading           = false;
  if (m_timerActive) {
    stopTimer();
    m_timerActive = false;
  }
}

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

void ThumbnailViewer::loadDirectory(const TFilePath &dirPath,
                                    const vector<string> &fileTypes) {
  clearItems();
  TFilePathSet fps;

  try {
    fps = TSystem::readDirectory(dirPath);
  } catch (...) {
    TMessage::error(toString(dirPath.getWideString()) +
                    ": can't read directory");
    updateContentSize();
    return;
  }

  fps = TSystem::packLevelNames(fps);
  fps.sort();

  for (TFilePathSet::iterator it = fps.begin(); it != fps.end(); it++) {
    try {
      TFilePath fp = *it;
      if (fp.getType() == "bmp" && fp.getName().find("_icon") != string::npos)
        continue;
      if (std::find(fileTypes.begin(), fileTypes.end(), fp.getType()) ==
          fileTypes.end())
        continue;
      Thumbnail *item = FileThumbnail::create(m_iconBox.getSize(), fp);
      if (item) m_items.push_back(item);
    } catch (...) {
      TMessage::error(toString(it->getWideString()) + ": can't read thumbnail");
    }
  }
  updateContentSize();
}

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

void ThumbnailViewer::updateContentSize() {
  int itemCount   = m_items.size();
  int columnCount = getColumnCount();
  int rowCount    = (itemCount + columnCount - 1) / columnCount;

  TRect rect;
  int yrange = rowCount * (m_itemSize.ly + m_itemSpace.ly) - m_itemSpace.ly +
               m_margins.ly * 2;
  setContentSize(TDimension(getLx(), yrange));
}

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

void ThumbnailViewer::scrollPage(int y) { doScrollTo_y(tmax(y, 0)); }