// Decentralized Media
//
// Douglas Thrift
//
// $Id$

#include <menes/standard.hh>

#include <menes-api/pcre/regex.hpp>
#include <menes-app/simple.hpp>
#include <menes-dbi/driver.hpp>
#include <menes-dbi/resultset.hpp>
#include <menes-etl/fnbind.hpp>
#include <menes-ios/helpers.hpp>
#include <menes-net/http/request.hpp>
#include <menes-net/http/response.hpp>

#include "DecentralizedMedia.hpp"

int Main(const app::Options& options)
{
	ext::RedBlackSet<ext::String> extensions, locals;
	api::Pcre::RegEx extension(_B("^-extension=(.+)$")), local(_B("^-local=(.+)$"));

	_foreach (const app::ArgumentList, arg, app::GetArguments())
	{
		api::Pcre::RegEx::Match match;

		if (match = extension(*arg))
			extensions.Insert(match[1]);
		else if (match = local(*arg))
			locals.Insert(match[1]);
	}

	if (extensions.IsEmpty())
		extensions.Insert(_B("mp3"));

	locals.Insert("Media");

	_S<DecentralizedMedia> media(extensions, locals);

	media.Block();

	return 0;
}

DecentralizedMedia::DecentralizedMedia(const ext::RedBlackSet<ext::String>& extensions, const ext::RedBlackSet<ext::String>& locals) : waf::Server(_B("Web")), process(bmp.IsRunning() ? NULL : new api::Process(_B("/usr/X11R6/bin/beep-media-player"))), connection(dbi::GetDriver("pgsql")->Connect("", "douglas", "", "media")), extensions(extensions)
{
	if (!locals.IsEmpty())
	{
		_L<ext::String> args(locals.Begin(), locals.End());

		_foreach (const ext::RedBlackSet<ext::String>, extension, extensions)
		{
			if (extension != _set.Begin())
				args.InsertLast(_B("-or"));

			args.InsertLast(_B("-iname"));
			args.InsertLast(_S<ios::String>() << _B("*.") << *extension);
		}

		_H<api::Process> find(new api::Process(_B("/usr/bin/find"), args));
		ext::String file;

		while (ios::ReadLine(*find->GetReader(), file))
			/*media.Insert(file)*/;

		find->Join();
	}

	AddPort(6996);
}

DecentralizedMedia::~DecentralizedMedia()
{
	if (!process.IsEmpty())
	{
		_H<api::Thread> thread(new api::Thread(etl::BindAll(&DecentralizedMedia::Destroy, this)));

		bmp.Quit();

		thread->Join();
	}
}

_L<ext::String> DecentralizedMedia::GetArtists() const
{
	_H<dbi::ResultSet> artists_(connection->Execute(_B("SELECT DISTINCT artist FROM files WHERE live = TRUE")));
	_L<ext::String> artists;

	while (artists_->MoveNext())
		artists.InsertLast(artists_->GetString(_B("artist")));

	return artists;
}

_L<ext::String> DecentralizedMedia::GetTitles() const
{
	_H<dbi::ResultSet> titles_(connection->Execute(_B("SELECT DISTINCT title FROM files WHERE live = TRUE")));
	_L<ext::String> titles;

	while (titles_->MoveNext())
		titles.InsertLast(titles_->GetString(_B("title")));

	return titles;
}

_L<ext::String> DecentralizedMedia::GetAlbums() const
{
	_H<dbi::ResultSet> albums_(connection->Execute(_B("SELECT DISTINCT album FROM files WHERE live = TRUE")));
	_L<ext::String> albums;

	while (albums_->MoveNext())
		albums.InsertLast(albums_->GetString(_B("album")));

	return albums;
}

_L<ext::String> DecentralizedMedia::GetGenres() const
{
	_H<dbi::ResultSet> genres_(connection->Execute(_B("SELECT DISTINCT album FROM files WHERE live = TRUE")));
	_L<ext::String> genres;

	while (genres_->MoveNext())
		genres.InsertLast(genres_->GetString(_B("genre")));

	return genres;
}

_L<MediaFolder> DecentralizedMedia::GetFolders() const
{
	_H<dbi::ResultSet> paths(connection->Execute(_B("SELECT DISTINCT root FROM files WHERE live = TRUE")));
	_L<MediaFolder> folders;

	while (paths->MoveNext())
		folders.InsertLast(MediaFolder(connection, paths->GetString(_B("path"))));

	return folders;
}

void DecentralizedMedia::Process(const net::Http::Request& request, net::Http::Response& response)
{
	if (request.method_ == _B("EXTENSIONS"))
	{
		response.SetStatus(200);

		_foreach (const ext::RedBlackSet<ext::String>, extension, extensions)
			response << *extension << ios::NewLineNoFlush;
	}
	else if (request.method_ == _B("MEDIA"))
	{
		// XXX: implement
	}
	else
		waf::Server::Process(request, response);
}