#include "music.h"
#include "decoder.h"
#include "encoder.h"
#include "transcode.h"

#include <boost/format.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/filesystem/fstream.hpp>

namespace music {

fs::path root_directory;

void init(std::string root) {
	// remove trailing slash
	if(boost::algorithm::ends_with(root, "/"))
		root = root.substr(0, root.size()-1);
	root_directory = root;
}

MusicListing::p get(const std::string path) {
	// prefix path with our root_directory
	fs::path p = root_directory / path;

	// don't allow requests with /../ in the path
	if(path.find("/../") != std::string::npos) {
		return MusicListing::p();
	}

	if(fs::is_directory(p)) {
		boost::shared_ptr<MusicListing> ml(new MusicDirectory(p));
		return ml;
	} else if(fs::is_regular_file(p)) {
		boost::shared_ptr<MusicListing> ml(new MusicTrack(p));
		return ml;
	}

	return MusicListing::p();
}

}; // namespace music

void MusicDirectory::render(HTTPRequest& req, HTTPResponse& res) {
	res.add_header("content-type", "text/html");

	for(PathListings::iterator it = directories.begin(); it != directories.end(); it++) {
		std::string rel_path = it->string().substr(music::root_directory.string().size());
		res.write(boost::str(boost::format("<a href=\"%s\">%s</a><br />") % rel_path % rel_path));
	}
	for(PathListings::iterator it = tracks.begin(); it != tracks.end(); it++) {
		std::string rel_path = it->string().substr(music::root_directory.string().size());
		res.write(boost::str(boost::format("<a href=\"%s\">%s</a><br />") % rel_path % rel_path));
	}
}

MusicTrack::MusicTrack(const fs::path path) {
	std::cout << path << std::endl;
	this->path = path;
}

MusicDirectory::MusicDirectory(const fs::path root) {
	this->path = root;
	std::cout << this->path << std::endl;

	fs::directory_iterator end_itr;
	for(fs::directory_iterator it(this->path); it != end_itr; it++) {
		if(fs::is_directory(it->status())) {
			directories.push_back(it->path());
		} else if(fs::is_regular_file(it->status())) {
			tracks.push_back(it->path());
		}
	}
}

void MusicTrack::render(HTTPRequest& req, HTTPResponse& res) {
	res.add_header("content-type", "application/octet-stream");

	fs::ifstream is(path, std::ios::binary | std::ios::in);

	if(req.query.find("decoder") != req.query.end() && req.query.find("encoder") != req.query.end()) {
		DecoderBase *d = decoder::get_decoder(req.query["decoder"]);
		EncoderBase *e = encoder::get_encoder(req.query["encoder"]);
		Transcoder t(is, res, *d, *e);
		t.run();
		delete d;
		delete e;
	} else {
		is.seekg(0, std::ios::end);
		res.add_header("content-length", boost::str(boost::format("%d") % is.tellg()));
		is.seekg(0, std::ios::beg);

		char data[0x1000];
		while(is.good()) {
			is.read(data, 0x1000);
			res.write(data, is.gcount());
		}
	}
}