/*
* Copyright (C) 2008 Emweb bv, Herent, Belgium.
*
* See the LICENSE file for terms of use.
*/
#include "Git.h"

#include <iostream>
#include <vector>
#include <stdio.h>
#include <ctype.h>

#include <Wt/WAny.h>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/filesystem.hpp>

using namespace Wt;

/*
* Small utility methods and classes.
*/
namespace {
unsigned char fromHex(char b)
{
if (b <= '9')
return b - '0';
else if (b <= 'F')
return (b - 'A') + 0x0A;
else
return (b - 'a') + 0x0A;
}

unsigned char fromHex(char msb, char lsb)
{
return (fromHex(msb) << 4) + fromHex(lsb);
}

char toHex(unsigned char b)
{
if (b < 0xA)
return '0' + b;
else
return 'a' + (b - 0xA);
}

void toHex(unsigned char b, char& msb, char& lsb)
{
lsb = toHex(b & 0x0F);
msb = toHex(b >> 4);
}

/*
* Run a command and capture its stdout into a string.
* Uses and maintains a cache.
*/
class POpenWrapper
{
public:
POpenWrapper(const std::string& cmd, Git::Cache& cache) {
std::string s = sanitize(cmd);

bool cached = false;

for (Git::Cache::iterator i = cache.begin(); i != cache.end(); ++i)
if (i->first == s) {
content_ = i->second;
status_ = 0;
cached = true;
cache.splice(cache.begin(), cache, i); // implement LRU
break;
}

if (!cached) {
std::cerr << s << std::endl;
FILE *stream = popen((s + " 2>&1").c_str(), "r");
if (!stream)
throw Git::Exception("Git: could not execute: '" + s + "'");

int n = 0;
do {
char buffer[32000];
n = fread(buffer, 1, 30000, stream);
buffer[n] = 0;
content_ += std::string(buffer, n);
} while (n);

status_ = pclose(stream);

if (status_ == 0) {
cache.pop_back(); // implement LRU
cache.push_front(std::make_pair(s, content_));
}
}

idx_ = 0;
}

std::string& readLine(std::string& r, bool stripWhite = true) {
r.clear();

while (stripWhite
&& (idx_ < content_.length()) && isspace(content_[idx_]))
++idx_;

while (idx_ < content_.size() && content_[idx_] != '\n') {
r += content_[idx_];
++idx_;
}

if (idx_ < content_.size())
++idx_;

return r;
}

const std::string& contents() const {
return content_;
}

bool finished() const {
return idx_ == content_.size();
}

int exitStatus() const {
return status_;
}

private:
std::string content_;
unsigned int idx_;
int status_;


std::string sanitize(const std::string& cmd) {
/*
* Sanitize cmd to not include any dangerous tokens that could allow
* execution of shell commands: <>&;|[$`
*/
std::string result;
std::string unsafe = "<>&;|[$`";

for (auto item : cmd) {
if (unsafe.find(item) == std::string::npos)
result += item;
}

return result;
}
};
}

/*
* About the git files:
* type="commit":
* - of a reference, like the SHA1 ID obtained from git-rev-parse of a
* particular revision
* - contains the SHA1 ID of the tree
*
* type="tree":
* 100644 blob 0732f5e4def48d6d5b556fbad005adc994af1e0b CMakeLists.txt
* 040000 tree 037d59672d37e116f6e0013a067a7ce1f8760b7c Wt
* <mode> SP <type> SP <object> TAB <file>
*
* type="blob": contents of a file
*/

Git::Exception::Exception(const std::string& msg)
: std::runtime_error(msg)
{ }

Git::ObjectId::ObjectId()
{ }

Git::ObjectId::ObjectId(const std::string& id)
{
if (id.length() != 40)
throw Git::Exception("Git: not a valid SHA1 id: " + id);

for (int i = 0; i < 20; ++i)
(*this)[i] = fromHex(id[2 * i], id[2 * i + 1]);
}

std::string Git::ObjectId::toString() const
{
std::string result(40, '-');

for (int i = 0; i < 20; ++i)
toHex((*this)[i], result[2 * i], result[2 * i + 1]);

return result;
}

Git::Object::Object(const ObjectId& anId, ObjectType aType)
: id(anId),
type(aType)
{ }

Git::Git()
: is_bare_(false),
cache_(3) // cache of 3 git results
{ }

void Git::setRepositoryPath(const std::string& repositoryPath)
{
namespace fs = boost::filesystem;
boost::system::error_code ignored;
is_bare_ = !fs::is_directory(fs::path(repositoryPath) / ".git", ignored);
repository_ = repositoryPath;
checkRepository();
}

Git::ObjectId Git::getCommitTree(const std::string& revision) const
{
Git::ObjectId commit = getCommit(revision);
return getTreeFromCommit(commit);
}

std::string Git::catFile(const ObjectId& id) const
{
std::string result;

if (!getCmdResult("cat-file -p " + id.toString(), result, -1))
throw Exception("Git: could not cat '" + id.toString() + "'");

return result;
}

Git::ObjectId Git::getCommit(const std::string& revision) const
{
std::string sha1Commit;
getCmdResult("rev-parse " + revision, sha1Commit, 0);
return ObjectId(sha1Commit);
}

Git::ObjectId Git::getTreeFromCommit(const ObjectId& commit) const
{
std::string treeLine;
if (!getCmdResult("cat-file -p " + commit.toString(), treeLine, "tree"))
throw Exception("Git: could not parse tree from commit '"
+ commit.toString() + "'");

std::vector<std::string> v;
boost::split(v, treeLine, boost::is_any_of(" "));
if (v.size() != 2)
throw Exception("Git: could not parse tree from commit '"
+ commit.toString() + "': '" + treeLine + "'");
return ObjectId(v[1]);
}

Git::Object Git::treeGetObject(const ObjectId& tree, int index) const
{
std::string objectLine;
if (!getCmdResult("cat-file -p " + tree.toString(), objectLine, index))
throw Exception("Git: could not read object %"
+ asString(index).toUTF8()
+ " from tree " + tree.toString());
else {
std::vector<std::string> v1, v2;
boost::split(v1, objectLine, boost::is_any_of("\t"));
if (v1.size() != 2)
throw Exception("Git: could not parse tree object line: '"
+ objectLine + "'");
boost::split(v2, v1[0], boost::is_any_of(" "));
if (v2.size() != 3)
throw Exception("Git: could not parse tree object line: '"
+ objectLine + "'");

const std::string& stype = v2[1];
ObjectType type;
if (stype == "tree")
type = Tree;
else if (stype == "blob")
type = Blob;
else
throw Exception("Git: Unknown type: " + stype);

Git::Object result(ObjectId(v2[2]), type);
result.name = v1[1];

return result;
}
}

int Git::treeSize(const ObjectId& tree) const
{
return getCmdResultLineCount("cat-file -p " + tree.toString());
}

std::string Git::baseCmd() const
{
if (is_bare_)
return "git --git-dir=" + repository_;
else
return "git --git-dir=" + repository_ + "/.git"
" --work-tree=" + repository_;
}

bool Git::getCmdResult(const std::string& gitCmd, std::string& result,
int index) const
{
POpenWrapper p(baseCmd() + " " + gitCmd, cache_);

if (p.exitStatus() != 0)
throw Exception("Git error: " + p.readLine(result));

if (index == -1) {
result = p.contents();
return true;
} else
p.readLine(result);

for (int i = 0; i < index; ++i) {
if (p.finished())
return false;
p.readLine(result);
}

return true;
}

bool Git::getCmdResult(const std::string& gitCmd, std::string& result,
const std::string& tag) const
{
POpenWrapper p(baseCmd() + " " + gitCmd, cache_);

if (p.exitStatus() != 0)
throw Exception("Git error: " + p.readLine(result));

while (!p.finished()) {
p.readLine(result);
if (boost::starts_with(result, tag))
return true;
}

return false;
}

int Git::getCmdResultLineCount(const std::string& gitCmd) const
{
POpenWrapper p(baseCmd() + " " + gitCmd, cache_);

std::string r;

if (p.exitStatus() != 0)
throw Exception("Git error: " + p.readLine(r));

int result = 0;
while (!p.finished()) {
p.readLine(r);
++result;
}

return result;
}

void Git::checkRepository() const
{
POpenWrapper p(baseCmd() + " branch", cache_);

std::string r;
if (p.exitStatus() != 0)
throw Exception("Git error: " + p.readLine(r));
}