--- DecentralizedMedia/Library.cpp	2005/07/04 05:13:07	546
+++ DecentralizedMedia/Library.cpp	2005/07/11 10:24:59	556
@@ -4,68 +4,176 @@
 //
 // $Id$
 
-#include <menes/standard.hh>
+#include <menes/c++/standard.hh>
 
-#include <menes-dbi/resultset.hpp>
+#include <menes/dbi/resultset.hpp>
 
 #include "Library.hpp"
 
-Library::Library(const _R<dbi::Connection>& connection) : connection(connection)
+Library::Library(const _R<Connector>& connector) : connector(connector)
 {
+	_R<dbi::Connection> connection(connector->Connect());
+
 	connection->Execute(_B("UPDATE files SET live = FALSE"));
+
+	connector->Release(connection);
 }
 
-_L<cse::String> Library::GetArtists() const
+_L<MediaFolder> Library::GetFolders(unsigned page) const
 {
-	_R<dbi::ResultSet> artists_(connection->Execute(_B("SELECT DISTINCT artist FROM files WHERE live = TRUE")));
-	_L<cse::String> artists;
+	_R<dbi::Connection> connection(connector->Connect());
+	_R<dbi::ResultSet> roots(connection->Parse(_B("SELECT DISTINCT root FROM files WHERE live = TRUE ORDER By root LIMIT 50 OFFSET ?"))->Execute(page * 50));
+	_L<MediaFolder> folders;
 
-	while (artists_->MoveNext())
-		artists.InsertLast(artists_->GetString(_B("artist")));
+	while (roots->MoveNext())
+		folders.InsertLast(GetFolder(roots->GetString(_B("root"))));
 
-	return artists;
+	connector->Release(connection);
+
+	return folders;
 }
 
-_L<cse::String> Library::GetTitles() const
+unsigned Library::GetFoldersPages() const
 {
-	_R<dbi::ResultSet> titles_(connection->Execute(_B("SELECT DISTINCT title FROM files WHERE live = TRUE")));
-	_L<cse::String> titles;
+	_R<dbi::Connection> connection(connector->Connect());
+	_R<dbi::ResultSet> count(connection->Execute(_B("SELECT count(DISTINCT root) FROM files WHERE live = TRUE")));
+	unsigned pages(0);
+
+	if (count->MoveNext())
+		pages = (count->Get<unsigned>(_B("count")) + 49) / 50;
 
-	while (titles_->MoveNext())
-		titles.InsertLast(titles_->GetString(_B("title")));
+	connector->Release(connection);
 
-	return titles;
+	return pages;
 }
 
-_L<cse::String> Library::GetAlbums() const
+_L<MediaFile> Library::GetFiles(const _L<By>& bys, const _L<cse::String>& items, unsigned page) const
 {
-	_R<dbi::ResultSet> albums_(connection->Execute(_B("SELECT DISTINCT album FROM files WHERE live = TRUE")));
-	_L<cse::String> albums;
+	if (bys.IsEmpty() || ext::Contains(bys, By::LAST) || bys.GetSize() != items.GetSize())
+		return _L<MediaFile>();
+
+	_S<ios::String> statement_;
+
+	statement_ << _B("SELECT path FROM files WHERE live = TRUE ");
+
+	_foreach (const _L<By>, by, bys)
+		statement_ << _B("AND ") << *by << _B(" = ? ");
+
+	statement_ << _B("ORDER BY path LIMIT 50 OFFSET ?");
+
+	_R<dbi::Connection> connection(connector->Connect());
+	_R<dbi::Statement> statement(connection->Parse(statement_));
+
+	_foreach (const _L<cse::String>, item, items)
+		statement->Set(_index, *item);
 
-	while (albums_->MoveNext())
-		albums.InsertLast(albums_->GetString(_B("album")));
+	statement->Set(items.GetSize(), page * 50);
 
-	return albums;
+	_R<dbi::ResultSet> paths(statement->Execute());
+	_L<MediaFile> files;
+
+	while (paths->MoveNext())
+		files.InsertLast(GetFile(paths->GetString(_B("path"))));
+
+	connector->Release(connection);
+
+	return files;
 }
 
-_L<cse::String> Library::GetGenres() const
+unsigned Library::GetFilesPages(const _L<By>& bys, const _L<cse::String>& items) const
 {
-	_R<dbi::ResultSet> genres_(connection->Execute(_B("SELECT DISTINCT album FROM files WHERE live = TRUE")));
-	_L<cse::String> genres;
+	if (bys.IsEmpty() || ext::Contains(bys, By::LAST) || bys.GetSize() != items.GetSize())
+		return 0;
+
+	_S<ios::String> statement_;
+
+	statement_ << _B("SELECT count(path) FROM files WHERE live = TRUE ");
+
+	_foreach (const _L<By>, by, bys)
+		statement_ << _B("AND ") << *by << _B(" = ?");
 
-	while (genres_->MoveNext())
-		genres.InsertLast(genres_->GetString(_B("genre")));
+	_R<dbi::Connection> connection(connector->Connect());
+	_R<dbi::Statement> statement(connection->Parse(statement_));
 
-	return genres;
+	_foreach (const _L<cse::String>, item, items)
+		statement->Set(_index, *item);
+
+	_R<dbi::ResultSet> count(statement->Execute());
+	unsigned pages(0);
+
+	if (count->MoveNext())
+		pages = (count->Get<unsigned>(_B("count")) + 49) / 50;
+
+	connector->Release(connection);
+
+	return pages;
 }
 
-_L<MediaFolder> Library::GetFolders() const
+_L<cse::String> Library::GetItems(_L<By> bys, _L<cse::String> items, unsigned page) const
 {
-	_R<dbi::ResultSet> roots(connection->Execute(_B("SELECT DISTINCT root FROM files WHERE live = TRUE")));
-	_L<MediaFolder> folders;
+	if (bys.IsEmpty() || ext::Contains(bys, By::LAST) || bys.GetSize() - 1 != items.GetSize())
+		return _L<cse::String>();
 
-	while (roots->MoveNext())
-		folders.InsertLast(MediaFolder(connection, roots->GetString(_B("root"))));
+	_S<ios::String> statement_;
+	By by(bys.Last());
 
-	return folders;
+	statement_ << _B("SELECT DISTINCT ") << by << _B(" FROM files WHERE live = TRUE ");
+
+	bys.RemoveLast();
+
+	_foreach (const _L<By>, by_, bys)
+		statement_ << _B("AND ") << *by_ << _B(" = ? ");
+
+	statement_ << _B("ORDER BY ") << by << _B(" LIMIT 50 OFFSET ?");
+
+	_R<dbi::Connection> connection(connector->Connect());
+	_R<dbi::Statement> statement(connection->Parse(statement_));
+
+	_foreach (const _L<cse::String>, item, items)
+		statement->Set(_index, *item);
+
+	statement->Set(items.GetSize(), page * 50);
+
+	_R<dbi::ResultSet> items_(statement->Execute());
+	
+	items.Clear();
+
+	while (items_->MoveNext())
+		items.InsertLast(items_->GetString(lexical_cast<cse::String>(by)));
+
+	connector->Release(connection);
+
+	return items;
+}
+
+unsigned Library::GetItemsPages(_L<By> bys, const _L<cse::String>& items) const
+{
+	if (bys.IsEmpty() || ext::Contains(bys, By::LAST) || bys.GetSize() - 1 != items.GetSize())
+		return 0;
+
+	_S<ios::String> statement_;
+	By by(bys.Last());
+
+	statement_ << _B("SELECT count(DISTINCT ") << by << _B(") FROM files WHERE live = TRUE");
+
+	bys.RemoveLast();
+
+	_foreach (const _L<By>, by_, bys)
+		statement_ << _B(" AND ") << *by_ << _B(" = ?");
+
+	_R<dbi::Connection> connection(connector->Connect());
+	_R<dbi::Statement> statement(connection->Parse(statement_));
+
+	_foreach (const _L<cse::String>, item, items)
+		statement->Set(_index, *item);
+
+	_R<dbi::ResultSet> count(statement->Execute());
+	unsigned pages(0);
+
+	if (count->MoveNext())
+		pages = (count->Get<unsigned>(_B("count")) + 49) / 50;
+
+	connector->Release(connection);
+
+	return pages;
 }