GitService.cpp

#include "git/GitService.h"

#include "settings/SettingsService.h"
#include "tools/ProcessRunner.h"

#include <QDir>
#include <QFileInfo>
#include <QProcess>
#include <QStandardPaths>
#include <QTimer>

namespace cold {

GitService::GitService(SettingsService& settings, QObject* parent)
    : QObject(parent), m_settings(settings), m_runner(new ProcessRunner(this)),
      m_refreshDebounce(new QTimer(this)) {
    m_refreshDebounce->setSingleShot(true);
    m_refreshDebounce->setInterval(kDebounceMs);
    connect(m_refreshDebounce, &QTimer::timeout, this, &GitService::onDebounceTimeout);

    connect(m_runner, &ProcessRunner::outputLine, this, &GitService::onOutputLine);
    connect(m_runner, &ProcessRunner::finished, this, &GitService::onProcessFinished);
    connect(m_runner, &ProcessRunner::failed, this, &GitService::onProcessFailed);
}

GitService::~GitService() {
    if (m_runner && m_runner->isRunning()) {
        m_runner->cancel();
    }
}

void GitService::initialize() {
    m_runner->initialize();
}

bool GitService::isRepository() const {
    return m_isRepo;
}

const QHash<QString, GitStatus>& GitService::statusMap() const {
    return m_status;
}

QString GitService::gitExecutable() const {
    QString path = m_settings.toolPath(QStringLiteral("git"));
    if (path.isEmpty()) {
        path = QStandardPaths::findExecutable(QStringLiteral("git"));
    }
    return path;
}

void GitService::detectRepository() {
    const bool wasRepo = m_isRepo;
    m_isRepo = false;

    if (m_projectRoot.isEmpty()) {
        if (wasRepo) {
            emit repositoryChanged(false);
        }
        return;
    }

    const QDir gitDir(m_projectRoot + QStringLiteral("/.git"));
    if (gitDir.exists()) {
        m_isRepo = true;
    } else {
        const QString gitPath = gitExecutable();
        if (!gitPath.isEmpty()) {
            QProcess proc;
            proc.setProgram(gitPath);
            proc.setArguments({QStringLiteral("-C"), m_projectRoot, QStringLiteral("rev-parse"),
                               QStringLiteral("--is-inside-work-tree")});
            proc.start();
            if (proc.waitForFinished(2000) && proc.exitCode() == 0) {
                const QByteArray out = proc.readAllStandardOutput().trimmed();
                m_isRepo = (out == "true");
            }
        }
    }

    if (wasRepo != m_isRepo) {
        emit repositoryChanged(m_isRepo);
    }
}

void GitService::setProjectRoot(const QString& root) {
    m_projectRoot = QFileInfo(root).canonicalFilePath();
    if (m_projectRoot.isEmpty() && !root.isEmpty()) {
        m_projectRoot = QFileInfo(root).absoluteFilePath();
    }
    detectRepository();
    scheduleRefresh();
}

void GitService::clearProject() {
    m_refreshDebounce->stop();
    m_runner->cancel();
    m_projectRoot.clear();
    m_isRepo = false;
    m_status.clear();
    m_pendingOp = GitPendingOp::None;
    m_stdoutAccum.clear();
    setBusy(false);
    emit repositoryChanged(false);
    emit statusUpdated(m_status);
}

void GitService::scheduleRefresh() {
    if (!m_isRepo || m_projectRoot.isEmpty()) {
        return;
    }
    m_refreshDebounce->start();
}

void GitService::refreshNow() {
    if (!m_isRepo || m_projectRoot.isEmpty()) {
        return;
    }

    const QString gitPath = gitExecutable();
    if (gitPath.isEmpty()) {
        emit gitError(QStringLiteral("git not found — install git or set tool path"));
        return;
    }

    m_refreshDebounce->stop();
    startOp(GitPendingOp::Status, {QStringLiteral("status"), QStringLiteral("--porcelain")});
}

void GitService::requestDiff(const QString& path) {
    if (!m_isRepo || path.isEmpty()) {
        return;
    }

    const QString gitPath = gitExecutable();
    if (gitPath.isEmpty()) {
        emit gitError(QStringLiteral("git not found — install git or set tool path"));
        return;
    }

    m_diffPath = QFileInfo(path).canonicalFilePath();
    if (m_diffPath.isEmpty()) {
        m_diffPath = QFileInfo(path).absoluteFilePath();
    }

    QString relative = QDir(m_projectRoot).relativeFilePath(m_diffPath);
    if (relative.startsWith(QLatin1String(".."))) {
        emit gitError(QStringLiteral("File is outside the project"));
        return;
    }

    GitStatus fileStatus = m_status.value(m_diffPath, GitStatus::None);
    QStringList args;
    if (fileStatus == GitStatus::Untracked) {
        args = {QStringLiteral("diff"), QStringLiteral("--no-index"), QStringLiteral("--no-color"),
                QStringLiteral("/dev/null"), relative};
    } else {
        args = {QStringLiteral("diff"), QStringLiteral("--no-color"), QStringLiteral("--"),
                relative};
    }

    startOp(GitPendingOp::Diff, args);
}

void GitService::stagePaths(const QStringList& paths) {
    if (!m_isRepo || paths.isEmpty()) {
        return;
    }

    const QString gitPath = gitExecutable();
    if (gitPath.isEmpty()) {
        emit gitError(QStringLiteral("git not found — install git or set tool path"));
        return;
    }

    m_stagePaths = paths;
    QStringList args = {QStringLiteral("add"), QStringLiteral("--")};
    for (const QString& path : paths) {
        QString relative = QDir(m_projectRoot).relativeFilePath(path);
        if (!relative.startsWith(QLatin1String(".."))) {
            args.append(relative);
        }
    }
    if (args.size() <= 2) {
        return;
    }

    startOp(GitPendingOp::Add, args);
}

void GitService::commit(const QString& message) {
    if (!m_isRepo || message.trimmed().isEmpty()) {
        return;
    }

    const QString gitPath = gitExecutable();
    if (gitPath.isEmpty()) {
        emit gitError(QStringLiteral("git not found — install git or set tool path"));
        return;
    }

    m_commitMessage = message;
    startOp(GitPendingOp::Commit,
            {QStringLiteral("commit"), QStringLiteral("-m"), message.trimmed()});
}

QStringList GitService::stagedPaths() const {
    return m_stagedPaths;
}

void GitService::onDebounceTimeout() {
    refreshNow();
}

void GitService::startOp(GitPendingOp op, const QStringList& args) {
    const QString gitPath = gitExecutable();
    if (gitPath.isEmpty()) {
        emit gitError(QStringLiteral("git not found — install git or set tool path"));
        return;
    }

    if (m_runner->isRunning()) {
        m_runner->cancel();
    }

    m_stdoutAccum.clear();
    m_pendingOp = op;
    m_finishedOp = GitPendingOp::None;
    setBusy(true);

    QStringList fullArgs = {QStringLiteral("-C"), m_projectRoot};
    fullArgs.append(args);
    m_runner->start(gitPath, fullArgs, m_projectRoot);
}

void GitService::onOutputLine(OutputChannel channel, const QString& line) {
    Q_UNUSED(channel);
    if (m_pendingOp == GitPendingOp::None) {
        return;
    }
    if (!m_stdoutAccum.isEmpty()) {
        m_stdoutAccum += QLatin1Char('\n');
    }
    m_stdoutAccum += line;
}

void GitService::onProcessFinished(int exitCode) {
    m_finishedOp = m_pendingOp;
    finishOp(exitCode);
    m_pendingOp = GitPendingOp::None;
    setBusy(false);
}

void GitService::onProcessFailed(const QString& message) {
    emit gitError(message);
    m_pendingOp = GitPendingOp::None;
    setBusy(false);
}

void GitService::finishOp(int exitCode) {
    switch (m_finishedOp) {
    case GitPendingOp::Status:
        if (exitCode == 0) {
            parseStatusOutput(m_stdoutAccum);
        } else {
            emit gitError(QStringLiteral("git status failed (exit %1)").arg(exitCode));
        }
        break;
    case GitPendingOp::Diff:
        if (exitCode == 0 || exitCode == 1) {
            emit diffReady(m_diffPath, m_stdoutAccum);
        } else {
            emit gitError(QStringLiteral("git diff failed (exit %1)").arg(exitCode));
        }
        break;
    case GitPendingOp::Add:
        if (exitCode == 0) {
            refreshNow();
        } else {
            emit gitError(QStringLiteral("git add failed (exit %1)").arg(exitCode));
        }
        break;
    case GitPendingOp::Commit:
        if (exitCode == 0) {
            emit commitFinished(true, QStringLiteral("Committed successfully"));
            refreshNow();
        } else {
            const QString err = m_stdoutAccum.isEmpty()
                                    ? QStringLiteral("git commit failed (exit %1)").arg(exitCode)
                                    : m_stdoutAccum;
            emit commitFinished(false, err);
            emit gitError(err);
        }
        break;
    default:
        break;
    }
    m_stdoutAccum.clear();
}

void GitService::parseStatusOutput(const QString& output) {
    m_stagedPaths.clear();
    m_status = parsePorcelain(output, m_projectRoot, &m_stagedPaths);
    emitStatus();
}

QHash<QString, GitStatus> GitService::parsePorcelain(const QString& output,
                                                     const QString& projectRoot,
                                                     QStringList* stagedOut) {
    QHash<QString, GitStatus> result;
    const QStringList lines = output.split(QLatin1Char('\n'), Qt::SkipEmptyParts);

    for (QString line : lines) {
        line = line.trimmed();
        if (line.isEmpty()) {
            continue;
        }

        GitStatus status = GitStatus::None;
        QString relativePath;
        QChar indexChar = QLatin1Char(' ');

        if (line.startsWith(QStringLiteral("??"))) {
            status = GitStatus::Untracked;
            relativePath = line.mid(3).trimmed();
        } else if (line.size() >= 3) {
            indexChar = line.at(0);
            const QChar worktree = line.at(1);
            status = statusFromChars(indexChar, worktree);
            relativePath = line.mid(3).trimmed();
            const int arrow = relativePath.indexOf(QStringLiteral(" -> "));
            if (arrow >= 0) {
                relativePath = relativePath.mid(arrow + 4).trimmed();
            }
            if (relativePath.startsWith(QLatin1Char('"')) &&
                relativePath.endsWith(QLatin1Char('"'))) {
                relativePath = relativePath.mid(1, relativePath.size() - 2);
            }
        } else {
            continue;
        }

        if (status == GitStatus::None || relativePath.isEmpty()) {
            continue;
        }

        const QString key = resolvePathKey(projectRoot, relativePath);
        const GitStatus existing = result.value(key, GitStatus::None);
        if (gitStatusPriority(status) > gitStatusPriority(existing)) {
            result.insert(key, status);
        }

        if (stagedOut && indexChar != QLatin1Char(' ') && indexChar != QLatin1Char('?') &&
            !key.isEmpty()) {
            if (!stagedOut->contains(key)) {
                stagedOut->append(key);
            }
        }
    }

    if (stagedOut) {
        stagedOut->sort();
    }

    return result;
}

GitStatus GitService::statusFromChars(QChar index, QChar worktree) {
    auto charStatus = [](QChar c) -> GitStatus {
        if (c == QLatin1Char('?')) {
            return GitStatus::Untracked;
        }
        if (c == QLatin1Char('D')) {
            return GitStatus::Deleted;
        }
        if (c == QLatin1Char('A')) {
            return GitStatus::Added;
        }
        if (c == QLatin1Char('R')) {
            return GitStatus::Renamed;
        }
        if (c == QLatin1Char('M') || c == QLatin1Char('T')) {
            return GitStatus::Modified;
        }
        return GitStatus::None;
    };

    const GitStatus wi = charStatus(worktree);
    const GitStatus idx = charStatus(index);

    if (gitStatusPriority(wi) >= gitStatusPriority(idx)) {
        return wi != GitStatus::None ? wi : idx;
    }
    return idx;
}

QString GitService::resolvePathKey(const QString& projectRoot, const QString& relativePath) {
    const QString absolute = QDir(projectRoot).absoluteFilePath(relativePath);
    const QString canonical = QFileInfo(absolute).canonicalFilePath();
    return canonical.isEmpty() ? absolute : canonical;
}

void GitService::emitStatus() {
    emit statusUpdated(m_status);
}

void GitService::setBusy(bool busy) {
    if (m_busy != busy) {
        m_busy = busy;
        emit busyChanged(busy);
    }
}

} // namespace cold