#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();
}