/*
 * Cantata
 *
 * Copyright (c) 2011-2022 Craig Drummond <craig.p.drummond@gmail.com>
 *
 * ----
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include "librarypage.h"
#include "covers.h"
#include "customactions.h"
#include "models/mpdlibrarymodel.h"
#include "mpd-interface/mpdconnection.h"
#include "mpd-interface/mpdstats.h"
#include "settings.h"
#include "stdactions.h"
#include "support/actioncollection.h"
#include "support/messagebox.h"
#include "widgets/genrecombo.h"
#include "widgets/menubutton.h"
#include <QRandomGenerator>

LibraryPage::LibraryPage(QWidget* p)
	: SinglePageWidget(p)
{
	genreCombo = new GenreCombo(this);
	connect(StdActions::self()->addRandomAlbumToPlayQueueAction, SIGNAL(triggered()), SLOT(addRandomAlbum()));
	connect(MPDConnection::self(), SIGNAL(updatingLibrary(time_t)), view, SLOT(updating()));
	connect(MPDConnection::self(), SIGNAL(updatedLibrary()), view, SLOT(updated()));
	connect(MPDConnection::self(), SIGNAL(updatingDatabase()), view, SLOT(updating()));
	connect(MPDConnection::self(), SIGNAL(updatedDatabase()), view, SLOT(updated()));
	connect(view, SIGNAL(itemsSelected(bool)), this, SLOT(controlActions()));
	connect(view, SIGNAL(doubleClicked(const QModelIndex&)), this, SLOT(itemDoubleClicked(const QModelIndex&)));
	view->setModel(MpdLibraryModel::self());
	connect(MpdLibraryModel::self(), SIGNAL(modelReset()), this, SLOT(modelReset()));

	view->allowCategorized();
	// Settings...
	Configuration config(metaObject()->className());
	view->setMode(ItemView::Mode_DetailedTree);
	MpdLibraryModel::self()->load(config);

	config.beginGroup(SqlLibraryModel::groupingStr(MpdLibraryModel::self()->topLevel()));
	view->load(config);
	view->setSearchToolTip(tr("<p>Enter a string to search artist, album, title, etc. To filter based on year, add <i>#year-range</i> to search string - e.g.</p><ul>"
	                          "<li><b><i>#2000</i></b> return tracks from 2000</li>"
	                          "<li><b><i>#1980-1989</i></b> return tracks from the 80's</li>"
	                          "<li><b><i>Blah #2000</i></b> to search for string <i>Blah</i> and only return tracks from 2000</li>"
	                          "</ul></p>"));

	showArtistImagesAction = new QAction(tr("Show Artist Images"), this);
	showArtistImagesAction->setCheckable(true);
	libraryAlbumSortAction = createMenuGroup(tr("Sort Albums"), QList<MenuItem>() << MenuItem(tr("Name"), LibraryDb::AS_AlArYr) << MenuItem(tr("Year"), LibraryDb::AS_YrAlAr),
	                                         MpdLibraryModel::self()->libraryAlbumSort(), this, SLOT(libraryAlbumSortChanged()));
	albumAlbumSortAction = createMenuGroup(tr("Sort Albums"), QList<MenuItem>() << MenuItem(tr("Album, Artist, Year"), LibraryDb::AS_AlArYr) << MenuItem(tr("Album, Year, Artist"), LibraryDb::AS_AlYrAr) << MenuItem(tr("Artist, Album, Year"), LibraryDb::AS_ArAlYr) << MenuItem(tr("Artist, Year, Album"), LibraryDb::AS_ArYrAl) << MenuItem(tr("Year, Album, Artist"), LibraryDb::AS_YrAlAr) << MenuItem(tr("Year, Artist, Album"), LibraryDb::AS_YrArAl) << MenuItem(tr("Modified Date"), LibraryDb::AS_Modified),
	                                       MpdLibraryModel::self()->albumAlbumSort(), this, SLOT(albumAlbumSortChanged()));

	MenuButton* menu = new MenuButton(this);
	viewAction = createViewMenu(QList<ItemView::Mode>() << ItemView::Mode_BasicTree << ItemView::Mode_SimpleTree
	                                                    << ItemView::Mode_DetailedTree << ItemView::Mode_List
	                                                    << ItemView::Mode_IconTop << ItemView::Mode_Categorized);
	menu->addAction(viewAction);

	menu->addAction(createMenuGroup(tr("Group By"), QList<MenuItem>() << MenuItem(tr("Genre"), SqlLibraryModel::T_Genre) << MenuItem(tr("Artist"), SqlLibraryModel::T_Artist) << MenuItem(tr("Album"), SqlLibraryModel::T_Album),
	                                MpdLibraryModel::self()->topLevel(), this, SLOT(groupByChanged())));
	genreCombo->setVisible(SqlLibraryModel::T_Genre != MpdLibraryModel::self()->topLevel());

	menu->addAction(libraryAlbumSortAction);
	menu->addAction(albumAlbumSortAction);
	showArtistImagesAction->setChecked(MpdLibraryModel::self()->useArtistImages());
	menu->addAction(showArtistImagesAction);
	connect(showArtistImagesAction, SIGNAL(toggled(bool)), this, SLOT(showArtistImagesChanged(bool)));
	showArtistImagesAction->setVisible(SqlLibraryModel::T_Album != MpdLibraryModel::self()->topLevel() && ItemView::Mode_IconTop != view->viewMode());
	albumAlbumSortAction->setVisible(SqlLibraryModel::T_Album == MpdLibraryModel::self()->topLevel());
	libraryAlbumSortAction->setVisible(SqlLibraryModel::T_Album != MpdLibraryModel::self()->topLevel());
	genreCombo->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
	init(ReplacePlayQueue | AppendToPlayQueue, QList<QWidget*>() << menu << genreCombo);
	connect(genreCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(doSearch()));
	view->addAction(StdActions::self()->addToStoredPlaylistAction);
	view->addAction(CustomActions::self());
#ifdef TagLib_FOUND
#ifdef ENABLE_DEVICES_SUPPORT
	view->addAction(StdActions::self()->copyToDeviceAction);
#endif
	view->addAction(StdActions::self()->organiseFilesAction);
	view->addAction(StdActions::self()->editTagsAction);
#ifdef ENABLE_REPLAYGAIN_SUPPORT
	view->addAction(StdActions::self()->replaygainAction);
#endif
	view->addAction(StdActions::self()->setCoverAction);
#ifdef ENABLE_DEVICES_SUPPORT
	view->addSeparator();
	view->addAction(StdActions::self()->deleteSongsAction);
#endif
#endif// TagLib_FOUND
	connect(view, SIGNAL(updateToPlayQueue(QModelIndex, bool)), this, SLOT(updateToPlayQueue(QModelIndex, bool)));
	view->setOpenAfterSearch(SqlLibraryModel::T_Album != MpdLibraryModel::self()->topLevel());
	view->setInfoText(tr("No music? Looks like your MPD is not configured correctly."));

	for (QAction* act : viewAction->menu()->actions()) {
		if (ItemView::Mode_Categorized == act->property(constValProp).toInt()) {
			act->setVisible(SqlLibraryModel::T_Album == MpdLibraryModel::self()->topLevel());
			break;
		}
	}
}

LibraryPage::~LibraryPage()
{
	Configuration config(metaObject()->className());
	MpdLibraryModel::self()->save(config);
	config.beginGroup(SqlLibraryModel::groupingStr(MpdLibraryModel::self()->topLevel()));
	view->save(config);
}

void LibraryPage::clear()
{
	MpdLibraryModel::self()->clear();
	view->goToTop();
}

QStringList LibraryPage::selectedFiles(bool allowPlaylists) const
{
	QModelIndexList selected = view->selectedIndexes();
	if (selected.isEmpty()) {
		return QStringList();
	}
	return MpdLibraryModel::self()->filenames(selected, allowPlaylists);
}

QList<Song> LibraryPage::selectedSongs(bool allowPlaylists) const
{
	QModelIndexList selected = view->selectedIndexes();
	if (selected.isEmpty()) {
		return QList<Song>();
	}
	return MpdLibraryModel::self()->songs(selected, allowPlaylists);
}

Song LibraryPage::coverRequest() const
{
	QModelIndexList selected = view->selectedIndexes(false);// Dont need sorted selection here...

	if (1 == selected.count()) {
		QList<Song> songs = MpdLibraryModel::self()->songs(QModelIndexList() << selected.first(), false);
		if (!songs.isEmpty()) {
			Song s = songs.at(0);

			if (SqlLibraryModel::T_Artist == static_cast<SqlLibraryModel::Item*>(selected.first().internalPointer())->getType()) {
				if (s.useComposer()) {
					s.setComposerImageRequest();
				}
				else {
					s.setArtistImageRequest();
				}
			}
			return s;
		}
	}
	return Song();
}

#ifdef ENABLE_DEVICES_SUPPORT
void LibraryPage::addSelectionToDevice(const QString& udi)
{
	QList<Song> songs = selectedSongs();

	if (!songs.isEmpty()) {
		emit addToDevice(QString(), udi, songs);
		view->clearSelection();
	}
}

void LibraryPage::deleteSongs()
{
	QList<Song> songs = selectedSongs();

	if (!songs.isEmpty()) {
		if (MessageBox::Yes == MessageBox::warningYesNo(this, tr("Are you sure you wish to delete the selected songs?\n\nThis cannot be undone."), tr("Delete Songs"), StdGuiItem::del(), StdGuiItem::cancel())) {
			emit deleteSongs(QString(), songs);
		}
		view->clearSelection();
	}
}
#endif

void LibraryPage::showSongs(const QList<Song>& songs)
{
	// Filter out non-mpd file songs...
	QList<Song> sngs;
	for (const Song& s : songs) {
		if (!s.file.isEmpty() && !s.hasProtocolOrIsAbsolute()) {
			sngs.append(s);
		}
	}

	if (sngs.isEmpty()) {
		return;
	}

	view->clearSearchText();

	bool first = true;
	for (const Song& s : sngs) {
		QModelIndex idx = MpdLibraryModel::self()->findSongIndex(s);
		if (idx.isValid()) {
			if (ItemView::Mode_SimpleTree == view->viewMode() || ItemView::Mode_DetailedTree == view->viewMode() || first) {
				view->showIndex(idx, first);
			}
			if (first) {
				first = false;
			}
			if (ItemView::Mode_SimpleTree != view->viewMode() && ItemView::Mode_DetailedTree != view->viewMode()) {
				return;
			}
		}
	}
}

void LibraryPage::showArtist(const QString& artist)
{
	view->clearSearchText();
	QModelIndex idx = MpdLibraryModel::self()->findArtistIndex(artist);
	if (idx.isValid()) {
		view->showIndex(idx, true);
		if (ItemView::Mode_SimpleTree == view->viewMode() || ItemView::Mode_DetailedTree == view->viewMode()) {
			while (idx.isValid()) {
				view->setExpanded(idx);
				idx = idx.parent();
			}
		}
	}
}

void LibraryPage::showAlbum(const QString& artist, const QString& album)
{
	view->clearSearchText();
	QModelIndex idx = MpdLibraryModel::self()->findAlbumIndex(artist, album);
	if (idx.isValid()) {
		view->showIndex(idx, true);
		if (ItemView::Mode_SimpleTree == view->viewMode() || ItemView::Mode_DetailedTree == view->viewMode()) {
			while (idx.isValid()) {
				view->setExpanded(idx);
				idx = idx.parent();
			}
		}
	}
}

void LibraryPage::itemDoubleClicked(const QModelIndex&)
{
	const QModelIndexList selected = view->selectedIndexes(false);// Dont need sorted selection here...
	if (1 != selected.size()) {
		return;//doubleclick should only have one selected item
	}
	SqlLibraryModel::Item* item = static_cast<SqlLibraryModel::Item*>(selected.at(0).internalPointer());
	if (SqlLibraryModel::T_Track == item->getType()) {
		addSelectionToPlaylist();
	}
}

void LibraryPage::setView(int v)
{
	SinglePageWidget::setView(v);
	showArtistImagesAction->setVisible(SqlLibraryModel::T_Album != MpdLibraryModel::self()->topLevel() && ItemView::Mode_IconTop != view->viewMode());
}

void LibraryPage::modelReset()
{
	genreCombo->update(MpdLibraryModel::self()->getGenres());
	int count = MpdLibraryModel::self()->trackCount();
	view->setMinSearchDebounce(count <= 12500 ? 1000u : count <= 18000 ? 1500u
	                                                                   : 2000u);
}

void LibraryPage::groupByChanged()
{
	QAction* act = qobject_cast<QAction*>(sender());
	if (!act) {
		return;
	}
	int mode = act->property(constValProp).toInt();

	Configuration config(metaObject()->className());
	config.beginGroup(SqlLibraryModel::groupingStr(MpdLibraryModel::self()->topLevel()));
	view->save(config);

	MpdLibraryModel::self()->setTopLevel((SqlLibraryModel::Type)mode);
	albumAlbumSortAction->setVisible(SqlLibraryModel::T_Album == MpdLibraryModel::self()->topLevel());
	libraryAlbumSortAction->setVisible(SqlLibraryModel::T_Album != MpdLibraryModel::self()->topLevel());
	showArtistImagesAction->setVisible(SqlLibraryModel::T_Album != MpdLibraryModel::self()->topLevel() && ItemView::Mode_IconTop != view->viewMode());
	genreCombo->setVisible(SqlLibraryModel::T_Genre != MpdLibraryModel::self()->topLevel());

	config.endGroup();
	config.beginGroup(SqlLibraryModel::groupingStr(MpdLibraryModel::self()->topLevel()));
	if (!config.hasEntry(ItemView::constViewModeKey)) {
		view->setMode(SqlLibraryModel::T_Album == mode ? ItemView::Mode_IconTop : ItemView::Mode_DetailedTree);
	}
	view->load(config);
	for (QAction* act : viewAction->menu()->actions()) {
		int viewMode = act->property(constValProp).toInt();
		if (viewMode == view->viewMode()) {
			act->setChecked(true);
		}
		if (ItemView::Mode_Categorized == viewMode) {
			act->setVisible(SqlLibraryModel::T_Album == MpdLibraryModel::self()->topLevel());
		}
		if (ItemView::Mode_IconTop == viewMode) {
			act->setVisible(SqlLibraryModel::T_Genre != MpdLibraryModel::self()->topLevel());
		}
	}
	view->setOpenAfterSearch(SqlLibraryModel::T_Album != MpdLibraryModel::self()->topLevel());
}

void LibraryPage::libraryAlbumSortChanged()
{
	QAction* act = qobject_cast<QAction*>(sender());
	if (act) {
		MpdLibraryModel::self()->setLibraryAlbumSort((LibraryDb::AlbumSort)act->property(constValProp).toInt());
	}
}

void LibraryPage::albumAlbumSortChanged()
{
	QAction* act = qobject_cast<QAction*>(sender());
	if (act) {
		MpdLibraryModel::self()->setAlbumAlbumSort((LibraryDb::AlbumSort)act->property(constValProp).toInt());
	}
}

void LibraryPage::showArtistImagesChanged(bool u)
{
	MpdLibraryModel::self()->setUseArtistImages(u);
}

void LibraryPage::updateToPlayQueue(const QModelIndex& idx, bool replace)
{
	QStringList files = MpdLibraryModel::self()->filenames(QModelIndexList() << idx, true);
	if (!files.isEmpty()) {
		emit add(files, replace ? MPDConnection::ReplaceAndplay : MPDConnection::Append, 0, false);
	}
}

void LibraryPage::addRandomAlbum()
{
	if (!isVisible()) {
		return;
	}

	QStringList genres;
	QStringList artists;
	QList<SqlLibraryModel::AlbumItem*> albums;
	QModelIndexList selected = view->selectedIndexes(false);// Dont need sorted selection here...
	for (const QModelIndex& idx : selected) {
		SqlLibraryModel::Item* item = static_cast<SqlLibraryModel::Item*>(idx.internalPointer());
		switch (item->getType()) {
		case SqlLibraryModel::T_Genre:
			genres.append(item->getId());
			break;
		case SqlLibraryModel::T_Artist:
			artists.append(item->getId());
			break;
		case SqlLibraryModel::T_Album:
			// Can only have albums selected if set to group by albums
			// ...controlActions ensures this!
			albums.append(static_cast<SqlLibraryModel::AlbumItem*>(item));
			break;
		default:
			break;
		}
	}

	LibraryDb::Album album;
	if (!albums.isEmpty()) {
		// We have albums selected, so choose a random one of these...
		SqlLibraryModel::AlbumItem* al = albums.at(QRandomGenerator::global()->bounded(albums.size()));
		album.artist = al->getArtistId();
		album.id = al->getId();
	}
	else {
		// If all items selected, then just choose random of all albums
		switch (MpdLibraryModel::self()->topLevel()) {
		case SqlLibraryModel::T_Genre:
			if (genres.size() == MpdLibraryModel::self()->rowCount(QModelIndex())) {
				genres = QStringList();
			}
			break;
		case SqlLibraryModel::T_Artist:
			if (artists.size() == MpdLibraryModel::self()->rowCount(QModelIndex())) {
				artists = QStringList();
			}
			break;
		case SqlLibraryModel::T_Album:
			genres = artists = QStringList();
			break;
		default:
			break;
		}
		album = MpdLibraryModel::self()->getRandomAlbum(genres, artists);
	}

	if (album.artist.isEmpty() || album.id.isEmpty()) {
		return;
	}
	QList<Song> songs = MpdLibraryModel::self()->getAlbumTracks(album.artist, album.id);
	if (!songs.isEmpty()) {
		QStringList files;
		for (const Song& s : songs) {
			files.append(s.file);
		}
		emit add(files, /*replace ? MPDConnection::ReplaceAndplay : */ MPDConnection::Append, 0, false);
	}
}

void LibraryPage::doSearch()
{
	MpdLibraryModel::self()->search(view->searchText(),
	                                genreCombo->isHidden() || genreCombo->currentIndex() <= 0 ? QString() : genreCombo->currentText());
}

void LibraryPage::controlActions()
{
	QModelIndexList selected = view->selectedIndexes(false);// Dont need sorted selection here...
	bool enable = selected.count() > 0;

	CustomActions::self()->setEnabled(enable);
	StdActions::self()->enableAddToPlayQueue(enable);
	StdActions::self()->addToStoredPlaylistAction->setEnabled(enable);
#ifdef TagLib_FOUND
	StdActions::self()->organiseFilesAction->setEnabled(enable && MPDConnection::self()->getDetails().dirReadable);
	StdActions::self()->editTagsAction->setEnabled(StdActions::self()->organiseFilesAction->isEnabled());
#ifdef ENABLE_REPLAYGAIN_SUPPORT
	StdActions::self()->replaygainAction->setEnabled(StdActions::self()->organiseFilesAction->isEnabled());
#endif
#ifdef ENABLE_DEVICES_SUPPORT
	StdActions::self()->deleteSongsAction->setEnabled(StdActions::self()->organiseFilesAction->isEnabled());
	StdActions::self()->copyToDeviceAction->setEnabled(StdActions::self()->organiseFilesAction->isEnabled());
#endif
#endif// TagLib_FOUND

	if (1 == selected.count()) {
		SqlLibraryModel::Item* item = static_cast<SqlLibraryModel::Item*>(selected.at(0).internalPointer());
		SqlLibraryModel::Type type = item->getType();
		StdActions::self()->setCoverAction->setEnabled((SqlLibraryModel::T_Artist == type /* && !static_cast<MusicLibraryItemArtist *>(item)->isComposer()*/) || SqlLibraryModel::T_Album == type);
	}
	else {
		StdActions::self()->setCoverAction->setEnabled(false);
	}

	bool allowRandomAlbum = isVisible() && !selected.isEmpty();
	if (allowRandomAlbum) {
		bool groupingAlbums = SqlLibraryModel::T_Album == MpdLibraryModel::self()->topLevel();
		for (const QModelIndex& idx : selected) {
			if (SqlLibraryModel::T_Track == static_cast<SqlLibraryModel::Item*>(idx.internalPointer())->getType() || (!groupingAlbums && SqlLibraryModel::T_Album == static_cast<SqlLibraryModel::Item*>(idx.internalPointer())->getType())) {
				allowRandomAlbum = false;
				break;
			}
		}
	}
	StdActions::self()->addRandomAlbumToPlayQueueAction->setVisible(allowRandomAlbum);
}

#include "moc_librarypage.cpp"
