#include "capture_paths.h"

#include <cassert>

namespace reasampler {

std::string normalizeSlashes(const std::string& path) {
    std::string out = path;
    for (char& c : out) {
        if (c == '\\') c = '/';
    }
    // Strip a single trailing slash so joins do not double up. Preserve a lone
    // "/" (root) — stripping it would turn root into empty.
    if (out.size() > 1 && out.back() == '/') {
        out.pop_back();
    }
    return out;
}

std::string sanitizeStem(const std::string& baseName) {
    std::string out;
    out.reserve(baseName.size());
    for (unsigned char c : baseName) {
        const bool keep = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
                          (c >= '0' && c <= '9') || c == '.' || c == '_' ||
                          c == '-';
        out.push_back(keep ? static_cast<char>(c) : '_');
    }
    // Collapse to a stable default if nothing usable survived (e.g. all spaces).
    // A stem of only separators ('.', '_', '-') is also unhelpful as a name.
    bool hasAlnum = false;
    for (unsigned char c : out) {
        if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
            (c >= '0' && c <= '9')) {
            hasAlnum = true;
            break;
        }
    }
    if (out.empty() || !hasAlnum) {
        return "capture";
    }
    return out;
}

BankPaths deriveBankPaths(const std::string& projectDir,
                          const std::string& baseName,
                          const std::string& uniqueTag) {
    const std::string dir = normalizeSlashes(projectDir);

    std::string stem = sanitizeStem(baseName);
    if (!uniqueTag.empty()) {
        stem += "_" + sanitizeStem(uniqueTag);
    }
    const std::string fileName = stem + ".wav";

    // Precondition: the capture shell must resolve a non-empty project directory
    // before calling this function. An empty projectDir would produce a bare
    // relative "reasampler_bank" path — the silent default-location fallback this
    // tool explicitly forbids. Assert in debug; leave absoluteDir empty in release
    // so any caller that ignores the precondition fails loudly at the render/stat
    // step rather than silently writing to CWD.
    assert(!dir.empty() && "deriveBankPaths: projectDir must not be empty");

    BankPaths p;
    p.fileStem     = stem;                                    // stem only — REAPER appends extension
    p.fileName     = fileName;
    p.relativePath = std::string(kBankSubfolder) + "/" + fileName;
    // absoluteDir intentionally omits a trailing slash (RENDER_FILE wants the
    // directory itself; RENDER_PATTERN supplies the file name separately).
    // Empty when precondition is violated (dir empty) — caller must not proceed.
    p.absoluteDir  = dir.empty() ? std::string{}
                                 : dir + "/" + kBankSubfolder;
    return p;
}

std::string resolveBankFile(const std::string& projectDir,
                            const std::string& relativePath) {
    // No default-location fallback (CLAUDE.md invariant): an empty project dir or
    // relative path yields empty, not a bare relative path resolved against CWD.
    if (projectDir.empty() || relativePath.empty()) {
        return {};
    }
    const std::string dir = normalizeSlashes(projectDir);
    const std::string rel = normalizeSlashes(relativePath);
    if (dir.empty() || rel.empty()) {
        return {};
    }
    return dir + "/" + rel;
}

BankRelocation deriveRelocationPlan(const std::string& oldProjectDir,
                                    const std::string& newProjectDir) {
    BankRelocation r;
    if (oldProjectDir.empty() || newProjectDir.empty()) {
        return r;  // needed=false, empty dirs — nothing to relocate
    }
    const std::string oldDir = normalizeSlashes(oldProjectDir);
    const std::string newDir = normalizeSlashes(newProjectDir);

    r.oldBankDir = oldDir + "/" + kBankSubfolder;
    r.newBankDir = newDir + "/" + kBankSubfolder;
    // A Save (in place) leaves the project dir unchanged — nothing to relocate.
    // Only a Save-As to a different directory needs the bank moved.
    r.needed = (oldDir != newDir);
    return r;
}

ProjectTransition classifyProjectTransition(bool sameProjectObject,
                                            const std::string& lastGuid,
                                            const std::string& lastPath,
                                            const std::string& currentGuid,
                                            const std::string& currentPath) {
    // 1. The GUID is the identity of record and is checked FIRST. A different
    //    stored GUID means a genuinely different project is active — Load ITS index.
    //    This catches the regression that pointer-primary classification missed:
    //    REAPER RECYCLES ReaProject* addresses across close/open, so a reopened /
    //    new project can reuse the previous project's address (sameProjectObject ==
    //    true) while carrying a different stored GUID. Deciding on the pointer alone
    //    then returned NoOp/SaveAsRelocate and the bank never reloaded. The GUID is
    //    immune to address recycling, so it leads. Also covers new/unsaved<->saved
    //    transitions (one GUID empty, the other not) and switching between two
    //    distinct saved projects.
    if (currentGuid != lastGuid) {
        return ProjectTransition::Load;
    }

    // From here currentGuid == lastGuid (they are equal; both may be empty for
    // unsaved projects). The pointer now disambiguates the same-GUID case.

    // 2. Same GUID but a DIFFERENT object is a forked sibling: Save-As copied our
    //    GUID onto a distinct project object. Load its (own) index; never relocate.
    //    Two unsaved projects (both GUIDs empty, distinct objects) also land here —
    //    Load, so switching between them installs the right in-memory state.
    if (!sameProjectObject) {
        return ProjectTransition::Load;
    }

    // 3. Same object AND same GUID with a NEW path is a genuine Save-As (the object
    //    identity is proven and the record identity is unchanged — only the .rpp
    //    moved). Also the first save of an unsaved project (both GUIDs empty, old
    //    path empty): SaveAsRelocate is safe there because deriveRelocationPlan
    //    no-ops on the empty old dir (empty-GUID safety preserved) while poll()
    //    mints a GUID.
    if (currentPath != lastPath) {
        return ProjectTransition::SaveAsRelocate;
    }

    // 4. Same object, same GUID, same path — Save in place / idle tick.
    return ProjectTransition::NoOp;
}

} // namespace reasampler