#include "filebrowser.h"
#include "thumbnail.h"
#include "thumbnailviewer.h"
#include "tw/treeview.h"
#include "tw/colors.h"
#include "tw/button.h"
#include "tw/scrollbar.h"
#include "tw/mainshell.h"
#include "tfilepath.h"
#include "tsystem.h"
#include "tenv.h"
 
#include "tw/message.h"
 
using namespace TwConsts;
 
//===================================================================
 
namespace {
 
#include "filebrowser_icons.h"
 
//===================================================================
 
class DirectoryBrowser : public ThumbnailViewer {
  TFilePath m_filepath;
  vector<string> m_fileTypes;
 
  GenericFileBrowserAction *m_fileSelChangeAction;
  GenericFileBrowserAction *m_fileDblClickAction;
 
public:
  DirectoryBrowser(TWidget *parent, const vector<string> &fileTypes)
      : ThumbnailViewer(parent)
      , m_fileSelChangeAction(0)
      , m_fileDblClickAction(0)
      , m_fileTypes(fileTypes) {}
 
  ~DirectoryBrowser() {
    if (m_fileSelChangeAction) delete m_fileSelChangeAction;
 
    if (m_fileDblClickAction) delete m_fileDblClickAction;
  }
 
  void setPath(const TFilePath &filepath);
  void setFilter(const vector<string> &fileTypes);
 
  TFilePath getPath() const { return m_filepath; }
 
  void onDoubleClick(int index);
  void onSelect(int index);
 
  void setFileSelChangeAction(GenericFileBrowserAction *action) {
    m_fileSelChangeAction = action;
  }
 
  void setFileDblClickAction(GenericFileBrowserAction *action) {
    m_fileDblClickAction = action;
  }
};
 
//-------------------------------------------------------------------
 
void DirectoryBrowser::setPath(const TFilePath &filepath) {
  m_filepath = filepath;
  loadDirectory(filepath, m_fileTypes);
}
 
//-------------------------------------------------------------------
 
void DirectoryBrowser::setFilter(const vector<string> &fileTypes) {
  m_fileTypes = fileTypes;
  if (!m_filepath.isEmpty()) loadDirectory(m_filepath, m_fileTypes);
}
 
//-------------------------------------------------------------------
 
void DirectoryBrowser::onDoubleClick(int index) {
  Thumbnail *thumbnail = getItem(index);
  if (thumbnail->getType() != Thumbnail::SCENE) return;
  TFilePath path =
      thumbnail->getPath().getParentDir() + (thumbnail->getName() + "_files");
  setPath(path);
  invalidate();
}
 
//-------------------------------------------------------------------
 
void DirectoryBrowser::onSelect(int index) {
  if (index != -1) {
    Thumbnail *thumbnail = getItem(index);
    if (m_fileSelChangeAction)
      m_fileSelChangeAction->sendCommand(thumbnail->getPath());
  }
}
 
//===================================================================
 
class MyTreeViewItem : public TTreeViewItem {
public:
  MyTreeViewItem(TTreeViewItemParent *parent) : TTreeViewItem(parent) {}
 
  TDimension getIconSize() const { return TDimension(26, 26); }
 
  void drawIcon(TTreeView *w, const TPoint &origin) {
    TRect rect(origin, getIconSize());
    w->setColor(TWidget::Black);
    w->drawRect(rect);
    rect = rect.enlarge(-4);
    w->setColor(Red);
    w->drawRect(rect);
    w->setColor(Blue);
    w->fillRect(rect.enlarge(-1));
  }
 
  void drawName(TTreeView *w, const TPoint &origin) {
    string name         = toString(getName());
    TDimension textSize = w->getTextSize(name);
    TDimension iconSize = getIconSize();
 
    TPoint pos = origin;
    pos.x += iconSize.lx;
 
    if (isSelected()) {
      w->setColor(ToonzHighlightColor);
      w->fillRect(pos.x + 2, pos.y + 2, pos.x + textSize.lx + 8,
                  pos.y + iconSize.ly - 1 - 2);
    }
    w->setColor(TWidget::Black);
    w->drawText(pos + TPoint(5, iconSize.ly / 2 - textSize.ly / 2), name);
  }
 
  /*
void draw(TTreeView *w, const TPoint &origin) {
drawIcon(w,origin);
drawName(w,origin);
}
*/
};
 
//===================================================================
 
class MyTreeView : public TTreeView {
public:
  MyTreeView(TWidget *parent, string name = "MyTreeView")
      : TTreeView(parent, name) {
    setBackgroundColor(White);
  }
 
  void drawButton(const TPoint &p, bool open) {
    int r1 = 3, r2 = 1;
    TRect rect(p.x - r1, p.y - r1, p.x + r1, p.y + r1);
    setColor(getBackgroundColor());
    fillRect(rect.enlarge(-1));
    setColor(Gray210);
    drawRect(rect);
    setColor(Black);
    drawLine(p.x - r2, p.y, p.x + r2, p.y);
    if (!open) drawLine(p.x, p.y - r2, p.x, p.y + r2);
  }
};
 
//===================================================================
 
class SimpleFileItem : public MyTreeViewItem {
  TFilePath m_path;
 
public:
  SimpleFileItem(TTreeViewItemParent *parent, const TFilePath &path)
      : MyTreeViewItem(parent), m_path(path) {
    setIsLeaf(true);
  }
 
  wstring getName() const { return m_path.withoutParentDir().getWideString(); }
 
  TFilePath getPath() const { return m_path; }
};
 
//-------------------------------------------------------------------
 
bool caseInsensitiveLessThan(const TFilePath &fp1, const TFilePath &fp2) {
  return (stricmp(toString(fp1.getWideString()).c_str(),
                  toString(fp2.getWideString()).c_str()) < 0);
}
 
//-------------------------------------------------------------------
 
class FileFolderItem : public MyTreeViewItem {
  TFilePath m_path;
 
public:
  FileFolderItem(TTreeViewItemParent *parent, const TFilePath &path)
      : MyTreeViewItem(parent), m_path(path) {}
  wstring getName() const {
    return m_path.isRoot() ? m_path.getWideString()
                           : m_path.withoutParentDir().getWideString();
  }
 
  TDimension getIconSize() const { return TDimension(16, 16); }
 
  void onOpen() {
    clearItems();
    try {
      TFilePathSet fps = TSystem::readDirectory(m_path);
      fps.sort(caseInsensitiveLessThan);
      for (TFilePathSet::iterator it = fps.begin(); it != fps.end(); it++) {
        if (TFileStatus(*it).isDirectory()) new FileFolderItem(this, *it);
        // else
        //  new SimpleFileItem(this, *it);
      }
    } catch (TException &e) {
      TMessage::error(toString(e.getMessage()));
    }
  }
  TFilePath getPath() const { return m_path; }
 
  void drawIcon(TTreeView *w, const TPoint &origin) {
    w->rectwrite(isOpen() ? openfolder : closedfolder, origin);
  }
};
 
//-------------------------------------------------------------------
 
class MyComputerFolder : public MyTreeViewItem {
public:
  MyComputerFolder(TTreeViewItemParent *parent) : MyTreeViewItem(parent) {}
 
  wstring getName() const { return toWideString("My Computer"); }
 
  void onOpen() {
    clearItems();
 
    TFilePathSet fps = TSystem::getDisks();
    for (TFilePathSet::iterator it = fps.begin(); it != fps.end(); it++) {
      TTreeViewItem *item = new FileFolderItem(this, *it);
    }
  }
  void drawIcon(TTreeView *w, const TPoint &origin) {
    w->rectwrite(mycomputer, origin);
  }
};
 
//-------------------------------------------------------------------
 
class HistoryFolder : public MyTreeViewItem {
public:
  HistoryFolder(TTreeViewItemParent *parent) : MyTreeViewItem(parent) {}
 
  wstring getName() const { return toWideString("History"); }
 
  void onOpen() { clearItems(); }
  void drawIcon(TTreeView *w, const TPoint &origin) {
    w->rectwrite(history, origin);
  }
};
 
//-------------------------------------------------------------------
 
class LibraryFolder : public MyTreeViewItem {
public:
  LibraryFolder(TTreeViewItemParent *parent) : MyTreeViewItem(parent) {}
 
  wstring getName() const { return toWideString("Library"); }
 
  void onOpen() {
    clearItems();
    TFilePath root = TEnv::getRootDir();
    new FileFolderItem(this, root + "patterns");
    new FileFolderItem(this, root + "images");
    new FileFolderItem(this, root + "scenes");
  }
  void drawIcon(TTreeView *w, const TPoint &origin) {
    w->rectwrite(library, origin);
  }
};
 
//-------------------------------------------------------------------
 
class WorkFolder : public FileFolderItem {
public:
  WorkFolder(TTreeViewItemParent *parent)
      : FileFolderItem(parent, TEnv::getRootDir() + "work") {}
 
  TDimension getIconSize() const { return TDimension(24, 24); }
 
  wstring getName() const { return toWideString("Work"); }
 
  void drawIcon(TTreeView *w, const TPoint &origin) {
    w->rectwrite(workinprogress, origin);
  }
};
//-------------------------------------------------------------------
 
class FileFolderTreeView : public MyTreeView {
  DirectoryBrowser *m_viewer;
  TTreeViewItem *m_myComputer;
 
public:
  FileFolderTreeView(TWidget *parent, DirectoryBrowser *viewer)
      : MyTreeView(parent), m_viewer(viewer) {
    m_myComputer = new MyComputerFolder(this);
    m_myComputer->open();
 
    /*
new HistoryFolder(this);
new LibraryFolder(this);
new WorkFolder(this);
*/
  }
 
  void leftButtonDoubleClick(const TMouseEvent &e);
 
  void onSelect(TTreeViewItem *item);
  void setCurrentDir(const TFilePath &dirPath);
};
 
//===================================================================
 
void FileFolderTreeView::leftButtonDoubleClick(const TMouseEvent &e) {
  TTreeViewItem *item = getSelectedItem();
  if (item) {
    if (!item->isOpen())
      item->open();
    else
      item->close();
 
    updateVisibleItems();
    invalidate();
  }
}
 
//-------------------------------------------------------------------
 
void FileFolderTreeView::onSelect(TTreeViewItem *item) {
  FileFolderItem *folder = dynamic_cast<FileFolderItem *>(item);
  if (folder && folder->getPath() != m_viewer->getPath()) {
    TFilePath path = folder->getPath();
    m_viewer->setPath(path);
    m_viewer->invalidate();
  }
}
 
//-------------------------------------------------------------------
 
TTreeViewItem *openChild(TTreeViewItem *folder, const TFilePath &childPath) {
  int count = folder->getItemCount();
  for (int i = 0; i < count; ++i) {
    FileFolderItem *item = dynamic_cast<FileFolderItem *>(folder->getItem(i));
 
    if (item && item->getPath() == childPath) {
      item->open();
      return item;
    }
  }
 
  return 0;
}
 
//-------------------------------------------------------------------
 
void FileFolderTreeView::setCurrentDir(const TFilePath &dirPath) {
  assert(TFileStatus(dirPath).isDirectory());
 
  list<TFilePath> ancestors;
  ancestors.push_back(dirPath);
 
  if (!dirPath.isRoot()) {
    TFilePath fp = dirPath;
    while (!(fp = fp.getParentDir()).isRoot()) ancestors.push_front(fp);
    ancestors.push_front(fp);
  }
 
  TTreeViewItem *folder = m_myComputer;
  while (!ancestors.empty() && folder) {
    TFilePath fp = ancestors.front();
    folder       = openChild(folder, fp);
    ancestors.pop_front();
  }
 
  if (folder) {
    updateVisibleItems();
    select(folder);
 
    TRect rect;
    getPlacement(m_selectedItemIndex, rect);
    int y = rect.getP00().y;
    if (y <= 0)
      y = m_yoffset - y;
    else if (y > getLy())
      y = m_yoffset - (rect.y1 - getLy());
    else
      y = m_yoffset;
 
    scrollToY(y);
 
    updateScrollbars();
  }
}
 
};  // anonymous namespace
 
//==============================================================================
//==============================================================================
 
class FileBrowser::Data {
public:
  Data() {}
  ~Data() {}
 
  FileFolderTreeView *m_tree;
  DirectoryBrowser *m_panel;
  TScrollbar *m_panelScb, *m_treeVscb, *m_treeHscb;
 
  TIconButton *m_upButton, *m_createFolderButton, *m_deleteFileButton;
 
  vector<string> m_fileTypes;
};
 
//-------------------------------------------------------------------
 
FileBrowser::FileBrowser(TWidget *parent, string name,
                         const vector<string> &fileTypes)
    : TWidget(parent, name), m_data(new Data()) {
  m_data->m_fileTypes = fileTypes;
 
  m_data->m_panel = new DirectoryBrowser(this, fileTypes);
  m_data->m_tree  = new FileFolderTreeView(this, m_data->m_panel);
 
  m_data->m_panelScb = new TScrollbar(this);
  m_data->m_treeHscb = new TScrollbar(this);
  m_data->m_treeVscb = new TScrollbar(this);
 
  m_data->m_panel->setScrollbars(0, m_data->m_panelScb);
  m_data->m_tree->setScrollbars(m_data->m_treeHscb, m_data->m_treeVscb);
 
  setBackgroundColor(Gray210);
 
  m_data->m_upButton = new TIconButton(this, parentfolder);
  tconnect(*m_data->m_upButton, this, &FileBrowser::selectParentDirectory);
 
  m_data->m_createFolderButton = new TIconButton(this, newfolder);
  m_data->m_deleteFileButton   = new TIconButton(this, trash);
}
 
//-------------------------------------------------------------------
 
FileBrowser::~FileBrowser() { delete m_data; }
 
//-------------------------------------------------------------------
 
void FileBrowser::setFilter(const vector<string> &fileTypes) {
  m_data->m_fileTypes = fileTypes;
  m_data->m_panel->setFilter(fileTypes);
}
 
//-------------------------------------------------------------------
 
void FileBrowser::draw() {
  setColor(White);
  fillRect(0, 0, 4, getLy() - 1);
 
  TPoint p;
  p = m_data->m_treeVscb->getGeometry().getP11();
 
  setColor(Gray150);
  drawLine(p.x + 1, 1, p.x + 1, p.y);
 
  p = m_data->m_panel->getGeometry().getP01();
  drawLine(p.x - 1, 1, p.x - 1, p.y);
  drawLine(p.x - 1, p.y + 1, getLx() - 2, p.y + 1);
}
 
//-------------------------------------------------------------------
 
void FileBrowser::configureNotify(const TDimension &d) {
  /*
TRect rect = getBounds();
int x = 200;
int w = 15;
int xa = x-w-4;
TDimension scbSize(w, rect.getLy());
m_data->m_tree->setGeometry(rect.x0,rect.y0,xa-1,rect.y1);
m_data->m_treeVscb->setGeometry(TPoint(xa,rect.y0),scbSize);
 
m_data->m_treeHscb->setGeometry(rect.x0, rect.y0,
x-1-scbSize,rect.y0+scbSize-1);
 
int buttonBarHeight = 30;
 
rect.y1 -= buttonBarHeight;
scbSize.ly -= buttonBarHeight;
 
m_data->m_panel->setGeometry(x,rect.y0,rect.x1-w,rect.y1);
m_data->m_panelScb->setGeometry(TPoint(rect.x1-w+1,rect.y0),scbSize);
 
int y = rect.y1+4;
 
m_data->m_upButton->setPosition(x-1, y);
m_data->m_createFolderButton->setPosition(x+25, y);
m_data->m_deleteFileButton->setPosition(rect.x1-26, y);
 
invalidate();
 
*/
 
  const int scbSize = 15;
 
  TRect rect = getBounds();
  int x      = 196;
 
  m_data->m_tree->setGeometry(rect.x0, rect.y0 + scbSize, x - 1 - scbSize,
                              rect.y1);
  m_data->m_treeVscb->setGeometry(x - scbSize, rect.y0 + scbSize, x - 1,
                                  rect.y1);
  m_data->m_treeHscb->setGeometry(rect.x0, rect.y0, x - 1 - scbSize,
                                  rect.y0 + scbSize - 1);
 
  int buttonBarHeight = 29;
 
  rect.y1 -= buttonBarHeight;
 
  m_data->m_panel->setGeometry(x + 4, rect.y0, rect.x1 - scbSize, rect.y1);
  m_data->m_panelScb->setGeometry(rect.x1 - scbSize + 1, rect.y0, rect.x1,
                                  rect.y1);
 
  int y = rect.y1 + 4;
  x += 4;
  m_data->m_upButton->setPosition(x - 1, y);
  m_data->m_createFolderButton->setPosition(x + 25, y);
  m_data->m_deleteFileButton->setPosition(rect.x1 - 26, y);
 
  m_data->m_upButton->invalidate();
  m_data->m_createFolderButton->invalidate();
  m_data->m_deleteFileButton->invalidate();
  m_data->m_treeVscb->invalidate();
  m_data->m_treeHscb->invalidate();
  m_data->m_tree->invalidate();
  invalidate();
}
 
//-------------------------------------------------------------------
 
void FileBrowser::setBackgroundColor(const TGuiColor &color) {
  TWidget::setBackgroundColor(color);
  m_data->m_panel->setBackgroundColor(color);
  m_data->m_tree->setBackgroundColor(color);
}
 
//-------------------------------------------------------------------
 
void FileBrowser::setFileSelChangeAction(GenericFileBrowserAction *action) {
  m_data->m_panel->setFileSelChangeAction(action);
}
 
//-------------------------------------------------------------------
 
void FileBrowser::setFileDblClickAction(GenericFileBrowserAction *action) {
  m_data->m_panel->setFileDblClickAction(action);
}
 
//-------------------------------------------------------------------
 
TFilePath FileBrowser::getCurrentDir() const {
  FileFolderItem *item =
      dynamic_cast<FileFolderItem *>(m_data->m_tree->getSelectedItem());
  if (item)
    return item->getPath();
  else
    return TFilePath();
}
 
//-------------------------------------------------------------------
 
void FileBrowser::setCurrentDir(const TFilePath &dirPath) {
  m_data->m_tree->setCurrentDir(dirPath);
}
 
//-------------------------------------------------------------------
 
void FileBrowser::selectParentDirectory() { m_data->m_tree->selectParent(); }