#!/usr/bin/env bash

print_help() {
    (>&2 cat <<EOF
Autogenerate an .sspt file for a package.
Usage: sspt autogen [-h|-?|--help]
           Print this help text and exit.
     - sspt autogen {-e|--edit} <package-name>
           Generate the .sspt file for this package and optionally edit
           it afterwards.
Supported VCSes: git, hg, svn, cvs, bzr, mtn, darcs
Supported build systems: npm, cargo, setuptools, idris, xbuild, stack,
    cabal, scons, gradle, sbt, bazel, meson, ninja, ant, mvn, cmake,
    qmake, autoconf, makefile
EOF
)
}

autogen_git() {
    cat >> ".sspt" <<EOF
sspt_pull() {
    git pull
}
sspt_version() {
    git rev-parse HEAD
}
sspt_prettyver() {
    git describe --long --tags | sed 's/\([^-]*-g\)/r\1/;s/-/./g'
}
EOF
}
autogen_hg() {
    cat >> ".sspt" <<EOF
sspt_pull() {
    hg pull
}
sspt_version() {
    hg identify -i
}
sspt_prettyver() {
    printf "r%s.%s" "\$(hg identify -n)" "\$(hg identify -i)"
}
EOF
}
autogen_svn() {
    cat >> ".sspt" <<EOF
sspt_pull() {
    svn up
}
sspt_version() {
    svnversion
}
sspt_prettyver() {
    local ver="\$(svnversion)"
    printf "r%s" "\${ver//[[:alpha:]]}"
}
EOF
}
autogen_cvs() {
    # CVS doesn't have 'global' commits...
    cat >> ".sspt" <<EOF
sspt_pull() {
    cvs update
}
sspt_version() {
    date +%Y%m%d
}
sspt_prettyver() {
    date +%Y%m%d
}
EOF
}
autogen_bzr() {
    cat >> ".sspt" <<EOF
sspt_pull() {
    bzr update
}
sspt_version() {
    bzr revno
}
sspt_prettyver() {
    printf "r%s" "\$(bzr revno)"
}
EOF
}
autogen_mtn() {
    cat >> ".sspt" <<EOF
sspt_pull() {
    mtn pull
    mtn update
}
sspt_version() {
    mtn log --last=1 --no-graph | grep "Revision" | egrep -o "[A-Za-z0-9]$"
}
sspt_prettyver() {
    mtn log --last=1 --no-graph | grep "Revision" | egrep -o "[A-Za-z0-9]$"
}
EOF
}
autogen_darcs() {
    cat >> ".sspt" <<EOF
sspt_pull() {
    darcs pull
}
sspt_version() {
    darcs log -n 1 | head -1 | egrep -o "[A-Za-z0-9]$"
}
sspt_prettyver() {
    darcs log -n 1 | head -1 | egrep -o "[A-Za-z0-9]$"
}
EOF
}
autogen_vcs() {
    if [ -d ".git/" ]; then
        autogen_git
    elif [ -d ".hg/" ]; then
        autogen_hg
    elif [ -d ".svn/" ]; then
        autogen_svn
    elif [ -d "CVSROOT/" ]; then
        autogen_cvs
    elif [ -d ".bzr/" ]; then
        autogen_bzr
    elif [ -d "_MTN/" ]; then
        autogen_mtn
    elif [ -d "_darcs/" ]; then
        autogen_darcs
    else
        (>&2 echo "NOTE: could not detect repository type of package" \
            "'$1', add the .sspt file to make updating this pacakge possible.")
        # no upstream?
        cat >> ".sspt" <<EOF
sspt_pull() {
    true
}
sspt_version() {
    date +%Y%m%d
}
sspt_prettyver() {
    date +%Y%m%d
}
EOF
    fi
}
autogen_buildsys() {
    local REL_DIR="."
    local RELI_DIR="."
    local SSPT_FILE=".sspt"
    local CHANGED_DIR=""
    if [ -z "$DONT_LOOK_INTO_BUILD" ] && [ -d "build" ]; then
        pushd "build" >/dev/null
        CHANGED_DIR=1
        SSPT_FILE="../$SSPT_FILE"
        REL_DIR="./build"
        RELI_DIR="../"
    fi

    if [ -f "PKGBUILD" ]; then
        cat >> "$SSPT_FILE" <<EOF
export SSPT_TRACK_FILES="no"
sspt_config() {
    makepkg -o
}
sspt_build() {
    makepkg -e
}
sspt_install() {
    makepkg -i --noconfirm && rm *.pkg.tar.xz
}
sspt_clean() {
    makepkg -c -e -o
}
sspt_clean_config() {
    true
}
EOF
    elif [ -f "APKBUILD" ]; then
        cat >> "$SSPT_FILE" <<EOF
export SSPT_TRACK_FILES="no"
sspt_config() {
    abuild prepare
}
sspt_build() {
    abuild build
}
sspt_install() {
    abuild package -i
}
sspt_clean() {
    abuild clean
}
sspt_clean_config() {
    abuild clean
    abuild cleancache
}
EOF
    elif [ -f "CMakeLists.txt" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    mkdir -p "$REL_DIR/cmake-build"
    pushd "$REL_DIR/cmake-build" >/dev/null
    cmake .. -DCMAKE_BUILD_TYPE=Release "-DCMAKE_INSTALL_PREFIX=\$SSPT_DEST_DIR"
    popd >/dev/null
}
sspt_build() {
    make -C "$REL_DIR/cmake-build" -j$(nproc)
}
sspt_install() {
    make -C "$REL_DIR/cmake-build" install
}
sspt_clean() {
    make -C "$REL_DIR/cmake-build" clean
}
sspt_clean_config() {
    rm -rf "$REL_DIR/cmake-build"
}
EOF
    elif [ -f "./configure.ac" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    autoreconf -i
    "$REL_DIR/configure" "--prefix=\$SSPT_DEST_DIR"
}
sspt_build() {
    make -j$(nproc)
}
sspt_install() {
    make install "PREFIX=\$SSPT_DEST_DIR" "prefix=\$SSPT_DEST_DIR" "DESTDIR=\$SSPT_DEST_DIR"
}
sspt_clean() {
    make clean
}
sspt_clean_config() {
    rm -rf "$REL_DIR/configure" "$REL_DIR/"*akefile "$REL_DIR/"config.*
}
EOF
    elif [ -f "./configure" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    "$REL_DIR/configure" "--prefix=\$SSPT_DEST_DIR"
}
sspt_build() {
    make -j$(nproc)
}
sspt_install() {
    make install "PREFIX=\$SSPT_DEST_DIR" "prefix=\$SSPT_DEST_DIR" "DESTDIR=\$SSPT_DEST_DIR"
}
sspt_clean() {
    make clean
}
sspt_clean_config() {
    rm -rf "$REL_DIR/"*akefile "$REL_DIR/"config.*
}
EOF
    elif file_exists_glob ./*.pro; then
        local PRO_FILE="$(find ./*.pro -maxdepth 1 -type f | head -1)"

        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    qmake -makefile "$REL_DIR/$PRO_FILE"
}
sspt_build() {
    make -j$(nproc)
}
sspt_install() {
    make install "PREFIX=\$SSPT_DEST_DIR" "prefix=\$SSPT_DEST_DIR" "DESTDIR=\$SSPT_DEST_DIR"
}
sspt_clean() {
    make clean
}
sspt_clean_config() {
    rm "$REL_DIR/*akefile"
}
EOF
    elif file_exists_glob ./*akefile; then # support GNUmakefile etc.
        local MAKEFILE=$(find ./*akefile -maxdepth 1 -type f | head -1)
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    true
}
sspt_build() {
    make -f "$MAKEFILE" -j$(nproc)
}
sspt_install() {
    make -f "$MAKEFILE" install "PREFIX=\$SSPT_DEST_DIR" "prefix=\$SSPT_DEST_DIR" "DESTDIR=\$SSPT_DEST_DIR"
}
sspt_clean() {
    make -f "$MAKEFILE" clean
}
sspt_clean_config() {
    true
}
EOF
    elif [ -f "package.json" ]; then
        cat >> "$SSPT_FILE" <<EOF
export SSPT_TRACK_FILES="no"
sspt_config() {
    >&2 echo "NOTE: npm doesn't honor \$SSPT_DEST_DIR"
}
sspt_build() {
    true
}
sspt_install() {
    npm install
}
sspt_clean() {
    true
}
sspt_clean_config() {
    rm -rf "$REL_DIR/node_packages"
}
EOF
    elif [ -f "Cargo.toml" ]; then
        cat >> "$SSPT_FILE" <<EOF
export SSPT_TRACK_FILES="no"
sspt_config() {
    >&2 echo "You may want to edit the .sspt file to enable or disable some features."
}
sspt_build() {
    cargo build --release
}
sspt_install() {
    cargo install --root \$SSPT_DEST_DIR
}
sspt_clean() {
    cargo clean --release
}
sspt_clean_config() {
    true
}
EOF
    elif [ -f "setup.py" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    >&2 echo "NOTE: sspt assumes that the setup.py script will be executed by the correct python binary."
    # ensure it is executable
    chmod +x $REL_DIR/setup.py
}
sspt_build() {
    "$REL_DIR/setup.py" build
}
sspt_install() {
    "$REL_DIR/setup.py" install -O2 --prefix \$SSPT_DEST_DIR
}
sspt_clean() {
    "$REL_DIR/setup.py" clean
}
sspt_clean_config() {
    "$REL_DIR/setup.py" clean -a
}
EOF
    elif [ -f "stack.yaml" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    stack build --only-configure
    (>&2 echo "NOTE: stack doesn't honor \$SSPT_DEST_DIR, but installs" \
        "everything to \$XDG_CONFIG_HOME , which is also the default value" \
        "of \$SSPT_DEST_DIR .")
}
sspt_build() {
    stack build --ghc-options -j$(nproc)
}
sspt_install() {
    stack install
}
sspt_clean() {
    stack clean
}
sspt_clean_config() {
    stack clean --full
}
EOF
    elif file_exists_glob ./*.cabal; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    cabal configure -O2 --user --prefix=\$SSPT_DEST_DIR --ghc-option=-j$(nproc)
}
sspt_build() {
    cabal build --ghc-option=-j$(nproc)
}
sspt_install() {
    cabal install --prefix=\$SSPT_DEST_DIR
}
sspt_clean() {
    cabal clean -s
}
sspt_clean_config() {
    rm -rf "$REL_DIR/dist"
}
EOF
    elif [ -f "SConstruct" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    (>&2 echo "NOTE: SCons cannot install packages.")
}
sspt_build() {
    scons
}
sspt_install() {
    (>&2 echo "NOTE: SCons cannot install packages.")
}
sspt_clean() {
    scons -c
}
sspt_clean_config() {
    true
}
EOF
    elif [ -f "build.gradle" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    (>&2 echo "NOTE: Gradle cannot install packages.")
}
sspt_build() {
    grdle -a
}
sspt_install() {
    (>&2 echo "NOTE: Gradle cannot install packages.")
}
sspt_clean() {
    (>&2 echo "NOTE: Gradle cannot clean packages.")
}
sspt_clean_config() {
    true
}
EOF
    elif file_exists_glob ./*.sbt; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    (>&2 echo "NOTE: sbt cannot install packages.")
}
sspt_build() {
    sbt
}
sspt_install() {
    (>&2 echo "NOTE: sbt cannot install packages.")
}
sspt_clean() {
    (>&2 echo "NOTE: sbt cannot clean packages.")
}
sspt_clean_config() {
    true
}
EOF
    elif [ -f "BUILD" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    (>&2 echo "NOTE: Bazel cannot install packages.")
}
sspt_build() {
    bazel build
}
sspt_install() {
    (>&2 echo "NOTE: Bazel cannot install packages.")
}
sspt_clean() {
    bazel clean
}
sspt_clean_config() {
    true
}
EOF
        (>&2 echo "NOTE: sspt cannot figure out which target to use. Please edit the .sstp file manually.")
        return 1
    elif [ -f "meson.build" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    meson --backend ninja --buildtype release --strip --prefix \$SSPT_DEST_DIR "$REL_DIR/build"
}
sspt_build() {
    ninja -C "$REL_DIR/build"
}
sspt_install() {
    ninja -C "$REL_BUILD/build" install
}
sspt_clean() {
    ninja -C "$REL_DIR/build" clean
}
sspt_clean_config() {
    rm -rf "$REL_DIR/build"
}
EOF
    elif [ -f "build.ninja" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    true
}
sspt_build() {
    ninja
}
sspt_install() {
    ninja install
}
sspt_clean() {
    ninja clean
}
sspt_clean_config() {
    true
}
EOF
    elif [ -f "build.xml" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    (>&2 echo "NOTE: ant cannot install packages.")
}
sspt_build() {
    ant
}
sspt_install() {
    (>&2 echo "NOTE: ant cannot install packages.")
}
sspt_clean() {
    ant clean
}
sspt_clean_config() {
    true
}
EOF
    elif [ -f "pom.xml" ]; then
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    true
}
sspt_build() {
    mvn -B package
}
sspt_install() {
    mvn -B install
}
sspt_clean() {
    mvn -B clean
}
sspt_clean_config() {
    true
}
EOF
    elif file_exists_glob ./*.ipkg; then
        local IPKG_FILE=$(find ./*.ipkg -maxdepth 1 -type f | head -1) # ensure it's only 1 file
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    (>&2 echo "NOTE: idris doesn't honor \$SSPT_DEST_DIR")
}
sspt_build() {
    idris --build "$REL_DIR/$IPKG_FILE"
}
sspt_install() {
    idris --install "$REL_DIR/$IPKG_FILE" && idris --installdoc "$REL_DIR/$IPKG_FILE"
}
sspt_clean() {
    idris --clean "$REL_DIR/$IPKG_FILE"
}
sspt_clean_config() {
    true
}
EOF
    elif file_exists_glob ./*.sln; then
        local SLN_FILE=$(find ./*.sln -maxdepth 1 -type f | head -1)
        local PROBABLE_PROJECT_NAME=${SLN_FILE%.*}
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    >&2 echo "NOTE: the 'install' command for xbuild projects is extremely hacky, you might want to tweak it."
}
sspt_build() {
    xbuild /p:Configuration=Release "$REL_DIR/$SLN_FILE"
}
sspt_install() {
    cp "$RELI_DIR/$PROBABLE_PROJECT_NAME/bin/Release/"*.exe \$SSPT_DEST_DIR/bin && \
        cp "$RELI_DIR/$PROBABLE_PROJECT_NAME/bin/Release/"*.dll \$SSPT_DEST_DIR/lib
}
sspt_clean() {
    xbuild /p:Configuration=Release "$REL_DIR/$SLN_FILE" /t:Clean
}
sspt_clean_config() {
    true
}
EOF
    elif ! [ -z "$CHANGED_DIR" ]; then
        # try top directory instead
        popd >/dev/null
        DONT_LOOK_INTO_BUILD=1 autogen_buildsys
        return $?
    else
        cat >> "$SSPT_FILE" <<EOF
sspt_config() {
    true
}
sspt_build() {
    true
}
sspt_install() {
    true
}
sspt_clean() {
    true
}
sspt_clean_config() {
    true
}
EOF
        (>&2 echo "Could not detect how to compile package '$1'.")
        return 1
    fi

    if ! [ -z "$CHANGED_DIR" ]; then
        popd >/dev/null
    fi
}

autogen_cwd() {
    if [ -f ".sspt" ]; then
        rm ".sspt"
    fi
    touch ".sspt"
    #echo "name=\"$(basename `pwd`)\"" >> ".sspt"
    autogen_vcs "$1"
    autogen_buildsys "$1"
    return $?
}

main() {
    local ESCAPED_PKG=$(escape_string "$1")

    case "$1" in
        "-h"|"-?"|"--help")
            print_help
            ;;
        "-e"|"--edit")
            if [ -z "$2" ]; then
                print_help
                exit
            fi

            main "$2"
            exec_subcommand edit "$2"
            ;;
        *)
            if ! exec_subcommand src-db exists "$1"; then
                (>&2 echo "Package '$1' doesn't exist.")
                exit 1
            fi

            local PACKAGE_DIR="$SSPT_DL_DIR/$ESCAPED_PKG"

            pushd "$PACKAGE_DIR" >/dev/null
            autogen_cwd "$1"
            local RETVAL=$?
            popd >/dev/null
            exit $RETVAL
            ;;
    esac
}

if [ $# -eq 0 ]; then
    print_help
    exit
fi

main "$@"