/***************************************************************************
 *   Copyright (C) 2008-2012 by Andrzej Rybczak                            *
 *   electricityispower@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; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
 ***************************************************************************/

#include <cassert>
#include <algorithm>

#include "charset.h"
#include "display.h"
#include "global.h"
#include "helpers.h"
#include "playlist.h"
#include "playlist_editor.h"
#include "mpdpp.h"
#include "status.h"
#include "tag_editor.h"
#include "utility/comparators.h"

using Global::MainHeight;
using Global::MainStartY;

PlaylistEditor *myPlaylistEditor = new PlaylistEditor;

namespace {//

size_t LeftColumnStartX;
size_t LeftColumnWidth;
size_t RightColumnStartX;
size_t RightColumnWidth;

std::string SongToString(const MPD::Song &s);
bool PlaylistEntryMatcher(const Regex &rx, const std::string &playlist);
bool SongEntryMatcher(const Regex &rx, const MPD::Song &s);

}

void PlaylistEditor::Init()
{
	LeftColumnWidth = COLS/3-1;
	RightColumnStartX = LeftColumnWidth+1;
	RightColumnWidth = COLS-LeftColumnWidth-1;
	
	Playlists = new Menu<std::string>(0, MainStartY, LeftColumnWidth, MainHeight, Config.titles_visibility ? "Playlists" : "", Config.main_color, brNone);
	Playlists->HighlightColor(Config.active_column_color);
	Playlists->CyclicScrolling(Config.use_cyclic_scrolling);
	Playlists->CenteredCursor(Config.centered_cursor);
	Playlists->setItemDisplayer(Display::Default<std::string>);
	
	Content = new Menu<MPD::Song>(RightColumnStartX, MainStartY, RightColumnWidth, MainHeight, Config.titles_visibility ? "Playlist's content" : "", Config.main_color, brNone);
	Content->HighlightColor(Config.main_highlight_color);
	Content->CyclicScrolling(Config.use_cyclic_scrolling);
	Content->CenteredCursor(Config.centered_cursor);
	Content->SetSelectPrefix(Config.selected_item_prefix);
	Content->SetSelectSuffix(Config.selected_item_suffix);
	if (Config.columns_in_playlist_editor)
		Content->setItemDisplayer(std::bind(Display::SongsInColumns, _1, *this));
	else
		Content->setItemDisplayer(std::bind(Display::Songs, _1, *this, Config.song_list_format));
	
	w = Playlists;
	isInitialized = 1;
}

void PlaylistEditor::Resize()
{
	size_t x_offset, width;
	GetWindowResizeParams(x_offset, width);
	
	LeftColumnStartX = x_offset;
	LeftColumnWidth = width/3-1;
	RightColumnStartX = LeftColumnStartX+LeftColumnWidth+1;
	RightColumnWidth = width-LeftColumnWidth-1;
	
	Playlists->Resize(LeftColumnWidth, MainHeight);
	Content->Resize(RightColumnWidth, MainHeight);
	
	Playlists->MoveTo(LeftColumnStartX, MainStartY);
	Content->MoveTo(RightColumnStartX, MainStartY);
	
	hasToBeResized = 0;
}

std::basic_string<my_char_t> PlaylistEditor::Title()
{
	return U("Playlist editor");
}

void PlaylistEditor::Refresh()
{
	Playlists->Display();
	mvvline(MainStartY, RightColumnStartX-1, 0, MainHeight);
	Content->Display();
}

void PlaylistEditor::SwitchTo()
{
	using Global::myScreen;
	using Global::myLockedScreen;
	
	if (myScreen == this)
		return;
	
	if (!isInitialized)
		Init();
	
	if (myLockedScreen)
		UpdateInactiveScreen(this);
	
	if (hasToBeResized || myLockedScreen)
		Resize();
	
	if (myScreen != this && myScreen->isTabbable())
		Global::myPrevScreen = myScreen;
	myScreen = this;
	Global::RedrawHeader = true;
	Refresh();
	UpdateSongList(Content);
}

void PlaylistEditor::Update()
{
	if (Playlists->ReallyEmpty())
	{
		Content->Clear();
		MPD::TagList list;
		Mpd.GetPlaylists(list);
		sort(list.begin(), list.end(), CaseInsensitiveSorting());
		for (MPD::TagList::iterator it = list.begin(); it != list.end(); ++it)
		{
			utf_to_locale(*it);
			Playlists->AddItem(*it);
		}
		Playlists->Window::Clear();
		Playlists->Refresh();
	}
	
	if (!Playlists->Empty() && Content->ReallyEmpty())
	{
		Content->Reset();
		size_t plsize = 0;
		Mpd.GetPlaylistContent(locale_to_utf_cpy(Playlists->Current().value()), [this, &plsize](MPD::Song &&s) {
			Content->AddItem(s, myPlaylist->checkForSong(s));
			++plsize;
		});
		if (plsize > 0)
		{
			std::string title = Config.titles_visibility ? "Playlist content (" + unsignedLongIntTo<std::string>::apply(plsize) + " item" + (plsize == 1 ? ")" : "s)") : "";
			title.resize(Content->GetWidth());
			Content->SetTitle(title);
		}
		else
			Content->SetTitle(Config.titles_visibility ? "Playlist content" : "");
		
		Content->Window::Clear();
		Content->Display();
	}
	
	if (w == Content && Content->ReallyEmpty())
	{
		Content->HighlightColor(Config.main_highlight_color);
		Playlists->HighlightColor(Config.active_column_color);
		w = Playlists;
	}
	
	if (Content->ReallyEmpty())
	{
		*Content << XY(0, 0) << "Playlist is empty.";
		Content->Window::Refresh();
	}
}

void PlaylistEditor::MoveSelectedItems(Playlist::Movement where)
{
	if (Content->Empty())
		return;
	
	// remove search results as we may move them to different positions, but
	// search rememebers positions and may point to wrong ones after that.
	Content->clearSearchResults();
	
	switch (where)
	{
		case Playlist::mUp:
		{
			if (Content->hasSelected())
			{
				std::vector<size_t> list;
				Content->GetSelected(list);
					
				if (list.front() > 0)
				{
					Mpd.StartCommandsList();
					std::vector<size_t>::const_iterator it = list.begin();
					for (; it != list.end(); ++it)
						Mpd.Move(Playlists->Current().value(), *it-1, *it);
					if (Mpd.CommitCommandsList())
					{
						for (it = list.begin(); it != list.end(); ++it)
							Content->Swap(*it-1, *it);
						Content->Highlight(list[(list.size()-1)/2]-1);
					}
				}
			}
			else
			{
				size_t pos = Content->Choice();
				if (pos > 0)
				{
					if (Mpd.Move(Playlists->Current().value(), pos-1, pos))
					{
						Content->Scroll(wUp);
						Content->Swap(pos-1, pos);
					}
				}
			}
			break;
		}
		case Playlist::mDown:
		{
			if (Content->hasSelected())
			{
				std::vector<size_t> list;
				Content->GetSelected(list);
				
				if (list.back() < Content->Size()-1)
				{
					Mpd.StartCommandsList();
					std::vector<size_t>::const_reverse_iterator it = list.rbegin();
					for (; it != list.rend(); ++it)
						Mpd.Move(Playlists->Current().value(), *it, *it+1);
					if (Mpd.CommitCommandsList())
					{
						Content->Highlight(list[(list.size()-1)/2]+1);
						for (it = list.rbegin(); it != list.rend(); ++it)
							Content->Swap(*it, *it+1);
					}
				}
			}
			else
			{
				size_t pos = Content->Choice();
				if (pos < Content->Size()-1)
				{
					if (Mpd.Move(Playlists->Current().value(), pos, pos+1))
					{
						Content->Scroll(wDown);
						Content->Swap(pos, pos+1);
					}
				}
			}
			break;
		}
	}
}

bool PlaylistEditor::isContentFiltered()
{
	if (Content->isFiltered())
	{
		ShowMessage("Function currently unavailable due to filtered playlist content");
		return true;
	}
	return false;
}


bool PlaylistEditor::isNextColumnAvailable()
{
	if (w == Playlists)
	{
		if (!Content->ReallyEmpty())
			return true;
	}
	return false;
}

bool PlaylistEditor::NextColumn()
{
	if (w == Playlists)
	{
		Playlists->HighlightColor(Config.main_highlight_color);
		w->Refresh();
		w = Content;
		Content->HighlightColor(Config.active_column_color);
		return true;
	}
	return false;
}

bool PlaylistEditor::isPrevColumnAvailable()
{
	if (w == Content)
	{
		if (!Playlists->ReallyEmpty())
			return true;
	}
	return false;
}

bool PlaylistEditor::PrevColumn()
{
	if (w == Content)
	{
		Content->HighlightColor(Config.main_highlight_color);
		w->Refresh();
		w = Playlists;
		Playlists->HighlightColor(Config.active_column_color);
		return true;
	}
	return false;
}

void PlaylistEditor::AddToPlaylist(bool add_n_play)
{
	MPD::SongList list;
	
	if (w == Playlists && !Playlists->Empty())
	{
		if (Mpd.LoadPlaylist(utf_to_locale_cpy(Playlists->Current().value())))
		{
			ShowMessage("Playlist \"%s\" loaded", Playlists->Current().value().c_str());
			if (add_n_play)
				myPlaylist->PlayNewlyAddedSongs();
		}
	}
	else if (w == Content && !Content->Empty())
	{
		bool res = myPlaylist->Add(Content->Current().value(), Content->Current().isBold(), add_n_play);
		Content->Current().setBold(res);
	}
	
	if (!add_n_play)
		w->Scroll(wDown);
}

void PlaylistEditor::SpacePressed()
{
	if (Config.space_selects && w == Content)
	{
		Content->Current().setSelected(!Content->Current().isSelected());
		w->Scroll(wDown);
	}
	else
		AddToPlaylist(0);
}

void PlaylistEditor::MouseButtonPressed(MEVENT me)
{
	if (!Playlists->Empty() && Playlists->hasCoords(me.x, me.y))
	{
		if (w != Playlists)
			PrevColumn();
		if (size_t(me.y) < Playlists->Size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
		{
			Playlists->Goto(me.y);
			if (me.bstate & BUTTON3_PRESSED)
			{
				size_t pos = Playlists->Choice();
				SpacePressed();
				if (pos < Playlists->Size()-1)
					Playlists->Scroll(wUp);
			}
		}
		else
			Screen<Window>::MouseButtonPressed(me);
		Content->Clear();
	}
	else if (!Content->Empty() && Content->hasCoords(me.x, me.y))
	{
		if (w != Content)
			NextColumn();
		if (size_t(me.y) < Content->Size() && (me.bstate & (BUTTON1_PRESSED | BUTTON3_PRESSED)))
		{
			Content->Goto(me.y);
			if (me.bstate & BUTTON1_PRESSED)
			{
				size_t pos = Content->Choice();
				SpacePressed();
				if (pos < Content->Size()-1)
					Content->Scroll(wUp);
			}
			else
				EnterPressed();
		}
		else
			Screen<Window>::MouseButtonPressed(me);
	}
}

MPD::Song *PlaylistEditor::CurrentSong()
{
	return w == Content && !Content->Empty() ? &Content->Current().value() : 0;
}

void PlaylistEditor::GetSelectedSongs(MPD::SongList &v)
{
	std::vector<size_t> selected;
	Content->GetSelected(selected);
	if (selected.empty())
		selected.push_back(Content->Choice());
	for (auto it = selected.begin(); it != selected.end(); ++it)
		v.push_back(Content->at(*it).value());
}

/***********************************************************************/

std::string PlaylistEditor::currentFilter()
{
	std::string filter;
	if (w == Playlists)
		filter = RegexFilter<std::string>::currentFilter(*Playlists);
	else if (w == Content)
		filter = RegexFilter<MPD::Song>::currentFilter(*Content);
	return filter;
}

void PlaylistEditor::applyFilter(const std::string &filter)
{
	if (w == Playlists)
	{
		Playlists->ShowAll();
		auto rx = RegexFilter<std::string>(filter, Config.regex_type, PlaylistEntryMatcher);
		Playlists->filter(Playlists->Begin(), Playlists->End(), rx);
	}
	else if (w == Content)
	{
		Content->ShowAll();
		auto rx = RegexFilter<MPD::Song>(filter, Config.regex_type, SongEntryMatcher);
		Content->filter(Content->Begin(), Content->End(), rx);
	}
}

/***********************************************************************/

bool PlaylistEditor::search(const std::string &constraint)
{
	bool result = false;
	if (w == Playlists)
	{
		auto rx = RegexFilter<std::string>(constraint, Config.regex_type, PlaylistEntryMatcher);
		result = Playlists->search(Playlists->Begin(), Playlists->End(), rx);
	}
	else if (w == Content)
	{
		auto rx = RegexFilter<MPD::Song>(constraint, Config.regex_type, SongEntryMatcher);
		result = Content->search(Content->Begin(), Content->End(), rx);
	}
	return result;
}

void PlaylistEditor::nextFound(bool wrap)
{
	if (w == Playlists)
		Playlists->NextFound(wrap);
	else if (w == Content)
		Content->NextFound(wrap);
}

void PlaylistEditor::prevFound(bool wrap)
{
	if (w == Playlists)
		Playlists->PrevFound(wrap);
	else if (w == Content)
		Content->PrevFound(wrap);
}

/***********************************************************************/

void PlaylistEditor::Locate(const std::string &name)
{
	if (!isInitialized)
		Init();
	Update();
	for (size_t i = 0; i < Playlists->Size(); ++i)
	{
		if (name == (*Playlists)[i].value())
		{
			Playlists->Highlight(i);
			Content->Clear();
			break;
		}
	}
	SwitchTo();
}

List *PlaylistEditor::GetList()
{
	if (w == Playlists)
		return Playlists;
	else if (w == Content)
		return Content;
	else // silence compiler
	{
		assert(false);
		return 0;
	}
}

namespace {//

std::string SongToString(const MPD::Song &s)
{
	std::string result;
	if (Config.columns_in_playlist_editor)
		result = s.toString(Config.song_in_columns_to_string_format);
	else
		result = s.toString(Config.song_list_format_dollar_free);
	return result;
}

bool PlaylistEntryMatcher(const Regex &rx, const std::string &playlist)
{
	return rx.match(playlist);
}

bool SongEntryMatcher(const Regex &rx, const MPD::Song &s)
{
	return rx.match(SongToString(s));
}

}