[ -z "$ENV_MODEL_PATH" ] && echo "Need to set ENV_MODEL_PATH to the model's path, exiting" && return 1;

[ -z "$REMOTEUSER" ] && REMOTEUSER="$USER"
[ -z "$FLEXLM_USER" ] && FLEXLM_USER="$REMOTEUSER"

[ ! -f "$ENV_MODEL_PATH/models/Linux64_GCC-4.1/RTSM_VE_AEMv8A.so" ] && echo "Can't find RTSM_VE_AEMv8A.so at \$ENV_MODEL_PATH/models/Linux64_GCC-4.1/
You set ENV_MODEL_PATH to $ENV_MODEL_PATH
Is this right?" && return 1;

export GLIT_DOC="Get linaro-image tools"
function glit() {
    if [ -e /etc/mandriva-release -o -e /etc/rosa-release ]; then
        bzr --version &>/dev/null || sudo urpmi bzr
    else
        sudo add-apt-repository ppa:linaro-maintainers/tools
        sudo apt-get update
        sudo apt-get install linaro-image-tools
        sudo apt-get install bzr
    fi
    bzr branch lp:linaro-image-tools
    if [ -e /etc/mandriva-release -o -e /etc/rosa-release ]; then
        # Workaround for linaro-image-tools pulling in dpkg dependencies even
        # when they aren't needed for the android part
        # This breaks linaro-media-create obviously -- but we don't need that
        sed -i -e 's,^from debian,#from debian,g' linaro-image-tools/linaro_image_tools/hwpack/builder.py linaro-image-tools/linaro_image_tools/hwpack/packages.py
        sed -i -e 's,^from apt,#from apt,g' linaro-image-tools/linaro_image_tools/hwpack/packages.py
        sed -i -e 's,^import apt,#import apt,g' linaro-image-tools/linaro_image_tools/hwpack/packages.py linaro-image-tools/linaro_image_tools/hwpack/tests/test_packages.py
    fi
}

export MAKEMMC_DOC="make mmc.bin from a source build"
function makemmc() {
    if [ ! -f ./linaro-image-tools/linaro-android-media-create ]; then
        echo "Run glit() first"
        return
    fi
    ./linaro-image-tools/linaro-android-media-create \
        --image_file mmc.bin \
        --image_size 2000M \
        --dev vexpress \
        --system out/target/product/vexpress/system.tar.bz2 \
        --userdata out/target/product/vexpress/userdata.tar.bz2 \
        --boot out/target/product/vexpress/boot.tar.bz2
}

export PREBUILT_MAKEMMC_DOC="make mmc.bin from a source build"
function prebuilt_makemmc() {
    if [ ! -f ./linaro-image-tools/linaro-android-media-create ]; then
        echo "Run glit() first"
        return
    fi
    ./linaro-image-tools/linaro-android-media-create \
        --image_file mmc.bin \
        --image_size 2000M \
        --dev vexpress \
        --system system.tar.bz2 \
        --userdata userdata.tar.bz2 \
        --boot boot.tar.bz2
}

function untarboot() {
    tar -jxvf out/target/product/vexpress/boot.tar.bz2
}

function placeramdisk() {
    if [ ! -e  boot/ramdisk.img ]; then
	echo "Run untarbuiltboot"
    fi
    mkdir -p out/target/product/vexpress/
    cp -af boot/ramdisk.img out/target/product/vexpress/
}

function untarbuiltboot() {
    tar -jxvf boot.tar.bz2
}

function updateboot() {
    if [ ! -e out/target/product/vexpress/boot/linux-system.axf ]; then
        echo "no out/target/product/vexpress/boot/linux-system.axf"
        echo "Run build, buildboot or bk followed by bi"
    fi
    mkdir -p boot
    cp -af out/target/product/vexpress/boot/linux-system.axf boot/linux-system.axf
}


export RESTARTSSH_DOC="kill the ssh connection to the license server"
function killssh() {
    local sshpid=$(ps aux | grep "[s]sh -L 8224" | awk '{print $2}')
    echo $sshpid
    if [ ! -z "$sshpid" ]; then
        kill -9 $sshpid
    else
        echo "Nothing to kill"
    fi
}

export RUN_DOC="run a build from a source build"
function run() {
    if [ "$1" == "debugger" ]; then
        export USE_MODEL=modeldebugger
    else
	export USE_MODEL=model_shell64
    fi

    export MODEL_PATH=$ENV_MODEL_PATH
    export PATH=$PATH:$MODEL_PATH/bin/
    export ARMLMD_LICENSE_FILE="8224@localhost"

    local grepssh=$(ps aux | grep "[s]sh -L 8224")
    echo $grepssh

    if [ -z "$grepssh" ]; then
        ssh -L 8224:localhost:8224 \
            -L 18224:localhost:18224 \
            -N $FLEXLM_USER@flexlm.linaro.org &
        sleep 5
    fi
    if [ ! -e boot/linux-system.axf ]; then
        echo "run untarboot or updateboot"
        return
    fi

    $USE_MODEL -a $(pwd)/boot/linux-system.axf $MODEL_PATH/models/Linux64_GCC-4.1/RTSM_VE_AEMv8A.so -C motherboard.mmc.p_mmc_file=$(pwd)/mmc.bin -C cluster.NUM_CORES=1 -C cluster.cpu0.unpredictable_WPMASKANDBAS=0 \
        -C cluster.cpu0.unpredictable_non-contigous_BAS=0 \
        -C cluster.cpu1.unpredictable_WPMASKANDBAS=0 \
        -C cluster.cpu1.unpredictable_non-contigous_BAS=0 \
        -C cluster.cpu2.unpredictable_WPMASKANDBAS=0 \
        -C cluster.cpu2.unpredictable_non-contigous_BAS=0 \
        -C cluster.cpu3.unpredictable_WPMASKANDBAS=0 \
        -C cluster.cpu3.unpredictable_non-contigous_BAS=0 \
        -C cluster.take_ccfail_undef=0 \
        -C motherboard.hostbridge.userNetworking=true -C motherboard.hostbridge.userNetPorts="5556=6565" -C motherboard.smsc_91c111.enabled=1
}

function testbuild() {
    prebuilt_makemmc
    untarbuiltboot
    run
}

export TESTBUILDALL_DOC="Run testbuildall after downloading:
boot.tar.bz2
system.tar.bz2
userdata.tar.bz2
"
function testbuildall() {
    glit
    testbuild
}

function runit() {
    untarboot
    run
}

function kitchensink() {
    build
    makemmc
    untarboot
    run
}

function bathsink() {
    makemmc
    untarboot
    run
}

export BUILD_DOC="make a build"
function build() {
    export CPUS=`grep -c processor /proc/cpuinfo`

    export TARGET_PRODUCT=vexpress
    export TARGET_SIMULATOR=false
    export TARGET_BUILD_VARIANT=eng
    export DEBUG_NO_STRICT_ALIASING=yes
    export DEBUG_NO_STDCXX11=yes
    export TOOLCHAIN_TRIPLET=arm-linux-androideabi
    export BUILD_FS_IMAGE=1
    export LINARO_BUILD_SPEC=juice-aosp
    export ANDROID_64=true

    . build/envsetup.sh
    export PATH=$PATH:`pwd`/gcc-linaro-aarch64-linux-gnu-4.7/bin

    if [ -z "$1" ]; then
        time make -j${CPUS} boottarball systemtarball userdatatarball showcommands 2>&1 | tee build_log.txt
    else
        make -j${CPUS} $1 showcommands 2>&1 | tee build_log.txt
    fi
}

export BUILD_DOC="just make boot stuff (rebuilds ramdisk.img)"
function buildboot() {
    export CPUS=`grep -c processor /proc/cpuinfo`

    export TARGET_PRODUCT=vexpress
    export TARGET_SIMULATOR=false
    export TARGET_BUILD_VARIANT=eng
    export DEBUG_NO_STRICT_ALIASING=yes
    export DEBUG_NO_STDCXX11=yes
    export TOOLCHAIN_TRIPLET=arm-linux-androideabi
    export BUILD_FS_IMAGE=1
    export LINARO_BUILD_SPEC=juice-aosp
    export ANDROID_64=true

    . build/envsetup.sh
    make -j${CPUS} boottarball
}


export BI_DOC="Build an image file, assumes kernel and ramdisk are up-to-date
Pass a ramdisk to use it, instead of the one that's part of the build"
function bi() {
    MSG="
You can get one by downloading a boot.tar.bz2 from:
  https://android-build.linaro.org/builds/~linaro-android-restricted/lindt-white/
  Downloads > target > vexpress
  tar -jxvf boot.tar.bz2
"
    local ramdisk=1

    if [ ! -e out/target/product/vexpress/obj/kernel/arch/arm64/boot/Image ]; then
        echo "Build your kernel first with bk"
        return
    fi

    if [ ! -e out/target/product/vexpress/ramdisk.img ]; then
        echo "The ramdisk doesn't exist at: out/target/product/vexpress/ramdisk.img"
        echo "Building without ramdisk"
	ramdisk=0
    fi

    ln -sf $(pwd)/out/target/product/vexpress/obj/kernel/arch/arm64/boot/Image out/target/product/vexpress/kernel
    ln -sf $(pwd)/out/target/product/vexpress/obj/kernel/scripts/dtc/dtc ./boot-wrapper/dtc
    ln -sf $(pwd)/kernel/arch/arm64/boot/dts/vexpress-v2p-aarch64.dts ./boot-wrapper/vexpress-v2p-aarch64.dts
    ln -sf $(pwd)/kernel/arch/arm64/boot/dts/vexpress-v2m-rs1.dtsi ./boot-wrapper/vexpress-v2m-rs1.dtsi
    ln -sf $(pwd)/kernel/arch/arm64/boot/dts/skeleton.dtsi ./boot-wrapper/skeleton.dtsi
    ln -sf $(pwd)/out/target/product/vexpress/kernel ./boot-wrapper/Image
    if [ $ramdisk == 1 ]; then
	ln -sf $(pwd)/out/target/product/vexpress/ramdisk.img ./boot-wrapper/filesystem.cpio.gz
	PATH=$(pwd)/gcc-linaro-aarch64-linux-gnu-4.7/bin:$PATH && \
            make -C ./boot-wrapper clean && \
            make -C ./boot-wrapper CROSS_COMPILE=aarch64-linux-android-
    else
	PATH=$(pwd)/gcc-linaro-aarch64-linux-gnu-4.7/bin:$PATH && \
            make -C ./boot-wrapper clean && \
	    sed 's/^INITRD_FLAGS/#INITRD_FLAGS/' <./boot-wrapper/Makefile | \
	    make -C ./boot-wrapper CROSS_COMPILE=aarch64-linux-android- -f-
    fi
    mkdir -p out/target/product/vexpress/boot
    cp -fa ./boot-wrapper/linux-system.axf out/target/product/vexpress/boot/linux-system.axf
    rm ./boot-wrapper/dtc
    rm ./boot-wrapper/vexpress-v2p-aarch64.dts
    rm ./boot-wrapper/vexpress-v2m-rs1.dtsi
    rm ./boot-wrapper/skeleton.dtsi
    rm ./boot-wrapper/Image
    if [ $ramdisk == 1 ]; then
	rm ./boot-wrapper/filesystem.cpio.gz
    fi
}

function targetterm() {
    telnet localhost 5000
}

function runadbhost() {
    export ANDROID_PRODUCT_OUT=$(realpath out/target/product/vexpress/)
    adb kill-server
    sleep 1
    adb connect 127.0.0.1:5556
    adb wait-for-device
    adb shell
}

function runadbtarget() {
    stop adbd
    setprop service.adb.tcp.port 6565
    start adbd
}


# http://www.linuxjournal.com/content/using-named-pipes-fifos-bash
#

function reader() {
    local pipe=/tmp/testpipe

    trap "rm -f $pipe" EXIT

    if [[ ! -p $pipe ]]; then
        mkfifo $pipe
    fi

    while true
    do
        if read line <$pipe; then
            if [[ "$line" == 'quit' ]]; then
                break
            fi
            eval $line
        fi
    done

    echo "Reader exiting"

}

function writer() {
    pipe=/tmp/testpipe

    if [[ ! -p $pipe ]]; then
        echo "Reader not running"
        exit 1
    fi


    if [[ "$1" ]]; then
        echo "$1" >$pipe
    else
        echo "Hello from $$" >$pipe
    fi
}


export PKG_DOC="Create an mmc.bin from compiled *.bz2s"
function pkg() {
    if [ ! -f ./linaro-image-tools/linaro-android-media-create ]; then
        bzr branch lp:linaro-image-tools
    fi

    export BINOUT=out/target/product/vexpress

    ./linaro-image-tools/linaro-android-media-create --image_file mmc.bin --image_size 2000M --dev vexpress --system  $BINOUT/system.tar.bz2 --userdata  $BINOUT/userdata.tar.bz2 --boot  $BINOUT/boot.tar.bz2
}

export MOUNTMMC_DOC="Mount the the partitions of the mmc.bin
Will extract all partiions to mmc
If you call this like ./mountmmc.sh you will extract all partitions
if you call this like ./mountmmc.sh 1 2 5 you will extract partitions 1, 2 and 5
"
function mountmmc() {
    if [ -d mmc ]; then
        echo mmc dir exists, exiting
        return
    fi

    mkdir mmc
    pushd mmc

    if [ "$#" == "0" ]; then
        parted -s ../mmc.bin unit s print | \
            awk '$1 ~ /[1-6]/ { gsub(/s/, "", $0); print $2,$4;\
system("dd if=../mmc.bin of="$1" bs=512 skip="$2" count="$4);\
system("mkdir d"$1);\
system("sudo mount -o loop "$1" d"$1); }'
    else
        for p in "$@"
        do
            parted -s ../mmc.bin unit s print | \
                awk '$1 ~ /['$p']/ { gsub(/s/, "", $0); print $2,$4;\
system("dd if=../mmc.bin of="$1" bs=512 skip="$2" count="$4);\
system("mkdir d"$1);\
system("sudo mount -o loop "$1" d"$1); }'
        done
    fi

    popd
}


export CLEANMMC_DOC="Deletes an mmc/ directory, created with mountmmc"
function cleanmmc() {
    if [ ! -d mmc ]; then
        echo No mmc directory, nothing to do, exiting!
        return
    fi

    pushd mmc
    sudo umount d*
    rm -rf *
    popd
    rm -rf mmc
}

export GETTOMBS_DOC="Get tombs from a booted image,
will put tombstones in tombstones/"
function gettombs() {
#just call with ./gettombs.sh

    mountmmc 5
    cp -r mmc/d5/tombstones .
    cleanmmc
}


export ORD_DOC="Open up a ramdisk for hacking"
function ord() {
    if [ -z "$1" ]; then
        local RAMDISK="../out/target/product/vexpress/ramdisk.img"
    else
        if [ ! -e "$1" ]; then
            echo "$1 doesn't exist"
            return
        fi
        local RAMDISK="../$1"
    fi

    if [ -d rd ]; then
        echo rd exists, refusing to overwrite
        return
    fi

    mkdir rd
    pushd rd
    pwd
    cp $RAMDISK ../filesystem.cpio.gz
    gzip -d ../filesystem.cpio.gz
    cpio -i < ../filesystem.cpio
    popd
}

export CRD_DOC="Close up a ramdisk, ord should have been run,
run bi after this to rebuild the axf file"
function crd() {
    if [ -z "$1" ]; then
        local RAMDISK="out/target/product/vexpress/ramdisk.img"
    else
        if [ ! -e "$1" ]; then
            echo "$1 doesn't exist"
            return
        fi
        local RAMDISK="$1"
    fi

   if [ ! -d rd ]; then
        echo No rd directory, nothing to do, exiting!
        return
    fi

    pushd rd
    find ./ | cpio -H newc -o > ../ramdisk
    gzip ../ramdisk -c > ../ramdisk.img
    cp ../ramdisk.img ../$RAMDISK
    popd
}


#just get stuff to build the kernel and boot loader
export GET_DOC="Just get stuff to rebuild the kernel and boot-wrapper"
function get() {
    git clone git://android.git.linaro.org/people/pfefferz/gcc-linaro-aarch64-linux-gnu-4.7
    pushd gcc-linaro-aarch64-linux-gnu-4.7
    git checkout 4.7-13.02
    popd
    git clone git://android.git.linaro.org/people/pfefferz/boot-wrapper-aarch64 boot-wrapper
    git clone git://git.linaro.org/kernel/linux-linaro-tracking kernel
    pushd kernel
    git checkout linux-linaro
    popd
}

export BK_DOC="Configure and build a kernel"
function bk() {
    export KERNEL_OUT=$(pwd)/out/target/product/vexpress/obj/kernel
    export CPUS=`grep -c processor /proc/cpuinfo`

    mkdir -p $KERNEL_OUT

    if [ ! -z "$1" ]; then
        PATH=$(pwd)/gcc-linaro-aarch64-linux-gnu-4.7/bin:$PATH && \
            make -j${CPUS} -C kernel O=$KERNEL_OUT ARCH=arm64 defconfig vexpress-android_defconfig
    fi
    PATH=$(pwd)/gcc-linaro-aarch64-linux-gnu-4.7/bin:$PATH && \
        make -j${CPUS} -C kernel O=$KERNEL_OUT ARCH=arm64 CROSS_COMPILE=aarch64-linux-android- Image
}

export CK_DOC="Build a kernel"
function ck() {
    export KERNEL_OUT=$(pwd)/out/target/product/vexpress/obj/kernel
    export CPUS=`grep -c processor /proc/cpuinfo`

    mkdir -p $KERNEL_OUT

    PATH=$(pwd)/gcc-linaro-aarch64-linux-gnu-4.7/bin:$PATH && \
        make -j${CPUS} -C kernel O=$KERNEL_OUT ARCH=arm64 menuconfig
}

export UPDATEBOOT_DOC="update boot/ from boot-wrapper/"
function updatebootfrombootwrapper() {
    export ANDROID_DIR=$(pwd)
    export KERNEL_OUT=$ANDROID_DIR/out/target/product/vexpress/obj/kernel
    cp -fa ./boot-wrapper/linux-system.axf ./boot/linux-system.axf
    cp -fa $KERNEL_OUT/arch/arm64/boot/Image ./boot/kernel
}

export BUILDRUN_DOC="Build everything and run (on previously checked-out source)"
function buildrun() {
    build
    glit
    bathsink
}

function getorupdatemanifest() {
    ./repo init -u ssh://$REMOTEUSER@linaro-private.git.linaro.org/srv/linaro-private.git.linaro.org/android/manifest.git -b linaro_android_4.2.2 -m vexpress-juice-aosp.xml
    sed -i "s/linaro-big-little-switcher-bot/$REMOTEUSER/" .repo/manifest.xml

}

function tohttp {
    wget http://bazaar.launchpad.net/~linaro-automation/linaro-android-build-tools/trunk/download/head:/sanitizemanifest.py-20121026100311-5cyxt3zk9wgvwohf-1/rewrite-manifest.py

    python rewrite-manifest.py .repo/manifest.xml > new-manifest.xml
    mv new-manifest.xml .repo/manifest.xml 
    time ./repo sync
}

function getsource() {
    curl "http://android.git.linaro.org/gitweb?p=tools/repo.git;a=blob_plain;f=repo;hb=refs/heads/stable" > repo
    chmod +x repo
    getorupdatemanifest
    tohttp
}

export GETANDBUILD_DOC="Get all source, build everything and run"
function getbuildrun() {
    getsource
    buildrun
}


function tagall {
    ./repo forall -c 'gtags'
}

export REMOVEGTAGS_DOC="travers the entire directory and remove GTAGS"
function removegtags {
    local names=( GTAGS GSYMS GPATH GRTAGS )
    for var in ${names[@]}; do
        find . -name "$var" -exec rm {} \;
    done
}

function genfilelist {
    local names=( "*.c" "*.cc" "*.cpp" "*.h" "*.java*" "*.s" )
    rm -rf filenames.txt
    touch filenames.txt
    for var in ${names[@]}; do
         find . -name "$var" -exec echo {} >> filenames.txt \;
    done
    grep "[^ ]+" filenames.txt > tmp
    mv tmp filenames.txt
}

function tagfilelist {
    gtags -f filenames.txt
}

function bkbi {
    bk
    bi
    updateboot
}

function crdbi {
    crd
    bi
    updateboot
}

function pushchanges {
    git push ssh://$REMOTEUSER@android.git.linaro.org:29418/people/pfefferz/at.git 'refs/heads/*' 'refs/tags/*'
}