simkitch

#!/bin/bash
#
# SimpleKitchen
#
# Copyright 2018 John Isaac "johnDaH4x0r" Calderon
# Contact: johnrexevery1 [at] gmail [dot] com
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
# Credits goes to:
# - Original author: Tukasz "JustArchi" Domeradzki

# Set sensitivity to errors
set +e

# Initial variables
VERSION="1.0" # Unused
TEMPDIR="TEMP"
TOOLSDIR="tools"
TOOLS=(which whoami basename dirname gcc java perl sed cut wget od wc cpio zip unzip tar)
XDALINK="http://forum.xda-developers.com/showthread.php?t=2597220"
GITHUBLINK="https://github.com/johndah4x0r/SimpleKitchen.git"
AUTOUPDATE="1"  # Defines if we should turn on auto updates, if available
GITHUBBRANCH="master"
NEEDEDGIT="1.8"
ACTIVE_PROJECT=""
ARCH="unknown"
CUSER="$(whoami)"

ALIGN=4
FULLPERFORMANCE=1
CBIN="" # Ramdisk compression method
DBIN="" # Ramdisk decompression method

META_INF="META-INF/com/google/android"
UPDATER_SCRIPT_HEAD="updater-script-00_HEAD" # Unused
UPDATER_SCRIPT_SYMLINKS="updater-script-10_SYMLINKS"
UPDATER_SCRIPT_PERMISSIONS="updater-script-20_PERMISSIONS"
UPDATER_SCRIPT_EXEC="updater-script-80_EXEC" # Unused
UPDATER_SCRIPT_USER="updater-script-85_USER" # Unused
UPDATER_SCRIPT_KERNEL="updater-script-90_KERNEL"
UPDATER_SCRIPT_MODEM="updater-script-91_MODEM"
UPDATER_SCRIPT_TAIL="updater-script-99_TAIL" # Unused

## Functions ##

### CORE ###

# Waits for user action
PRESS_ENTER() {
    read -rp "Press <Enter> to continue..." >/dev/null
}

PRINT_LINE() {
    SIZE="$(stty size | cut -d ' ' -f 2)"
    SIZE="$((SIZE - 1))"

    for i in $(seq $SIZE); do
        echo -n '-'
    done
    echo ''
}

# Executes commands given in arguments as root
ROOT_EXECUTE() {
    # NOTE: Some sections have to brake spaces
    if [[ "$CUSER" = "root" ]]; then
        $@  # BRAKE SPACES
    else
        echo "Root access is required!"
        echo "Submit password when asked for it..."
        if [[ ! -z "$(which sudo)" ]]; then
            sudo $@ # BRAKE SPACES
        else
            su -c $@    # BRAKE SPACES
        fi
    fi
}

# Compares two versions
VERSION_LESS_THAN() {
    # $1 - Input version
    # $2 - Compared version
    # Returns true if $1 < $2, false otherwise
    if [[ "$1" != "$2" && "$(echo -e "$1\n$2" | sort -V | head -n 1)" = "$1" ]]; then
        return 0
    else
        return 1
    fi
}

# Changes matching word to another one
SED_CHANGE_WORD() {
    # $1 - What we're changing
    # $2 - To what we're changing
    # $3 - File location for that
    # $4 - Unique delimiter (optional)
    if [[ -z "$4" ]]; then
        sed -i 's/'"$1"'/'"$2"'/g' "$3"
    else
        sed -i 's'"$4""$1""$4""$2""$4"'g' "$3"
    fi
}

# Removes all lines which match the word
GREP_DELETE_WORD() {
    # $1 - What we're deleting
    # $2 - File location for that
    grep -v "$1" "$2" > "$2.tmp" && mv -f "$2.tmp" "$2"
}

# Performs cleaning of files/folders based on given blacklist
BLACKLIST_CLEAN() (
    # $1 - target cleaning list
    # $2 - target folder
    mkdir -p "$ACTIVE_PROJECT/$2"
    if [[ -f "files/$1/clean.txt" ]]; then
        while read -r line; do
            if [[ -z "$line" || "$line" = \#* ]]; then
                continue
            fi
            TARGETS="$(echo "$line" | awk '{print $1}' | cut -d '"' -f2)"
            case "$TARGETS" in
                /*) ;;
                *.apk)
                    TARGETS="$(echo "$TARGETS" | rev | cut -d'.' -f2- | rev)"
                    TARGETS="/system/app/$TARGETS /system/app/$TARGETS.apk /system/app/$TARGETS.odex /system/priv-app/$TARGETS /system/priv-app/$TARGETS.apk /system/priv-app/$TARGETS.odex"
                ;;
                *.jar)
                    TARGETS="$(echo "$TARGETS" | rev | cut -d'.' -f2- | rev)"
                    TARGETS="/system/framework/$TARGETS.jar /system/framework/$TARGETS.odex"
                ;;
                *.so) TARGETS="/system/lib/$TARGETS" ;;
            esac
            for TARGET in $TARGETS; do
                TARGETDIR="$ACTIVE_PROJECT/$2$(dirname "$TARGET")"
                mkdir -p "$TARGETDIR"
                if [[ -e "$ACTIVE_PROJECT"$TARGET ]]; then
                    echo "Cleaning $(basename "$ACTIVE_PROJECT$TARGET")"
                fi
                ACTIVE_TARGET="$ACTIVE_PROJECT"
                ACTIVE_TARGET+="$TARGET"
                mv -f "$ACTIVE_TARGET" "$TARGETDIR" >/dev/null 2>&1 # Yes, we must detect wildcards here
            done
        done < "files/$1/clean.txt"
    fi
)

# Restores previously cleaned files/folders
BLACKLIST_CLEAN_RESTORE() {
    # $1 - target folder
    cp -R "${ACTIVE_PROJECT}/$1"/* "$ACTIVE_PROJECT"
    rm -rf "${ACTIVE_PROJECT}/$1"
}

# Deletes files/folders based on given blacklist
BLACKLIST_REMOVE() (
    # $1 - target remove list
    if [[ -f "files/$1/remove.txt" ]]; then
        while read -r line; do
            if [[ -z "$line" || "$line" = \#* ]]; then
                continue
            fi
            local TARGET
            TARGETS="$(echo "$line" | awk '{print $1}' | cut -d '"' -f2)"
            case "$TARGETS" in
                /*) ;;
                *.apk)
                    TARGETS="$(echo "$TARGETS" | rev | cut -d'.' -f2- | rev)"
                    TARGETS="/system/app/$TARGETS /system/app/$TARGETS.apk /system/app/$TARGETS.odex /system/priv-app/$TARGETS /system/priv-app/$TARGETS.apk /system/priv-app/$TARGETS.odex"
                ;;
                *.jar)
                    TARGETS="$(echo "$TARGETS" | rev | cut -d'.' -f2- | rev)"
                    TARGETS="/system/framework/$TARGETS.jar /system/framework/$TARGETS.odex"
                ;;
                *.so) TARGETS="/system/lib/$TARGETS" ;;
            esac
            for TARGET in $TARGETS; do
                ACTIVE_TARGET="$ACTIVE_PROJECT"
                ACTIVE_TARGET+="$TARGET"
                if [[ -e "$ACTIVE_TARGET" ]]; then
                    echo "Removing $(basename "$ACTIVE_TARGET")"
                fi
                rm -rf "$ACTIVE_TARGET" >/dev/null 2>&1 # Yes, we must detect wildcards here
            done
        done < "files/$1/remove.txt"
    fi
)

# Gives user choice in choosing one thing from a few
PICK_ONE() {
    # $1 - A folder with subdirectories, which are offered as a choice
    PICKCHOICE="" # This must be a global variable
    while [[ -z "$PICKCHOICE" ]]; do
        PRINT_BANNER
        echo "Currently available for selection:"
        PRINT_LINE
        find "$1" -mindepth 1 -maxdepth 1 -type d | sort | while read -r line; do
            basename "$line"
        done
        PRINT_LINE
        echo
        echo "Type any of above or 'x' to abort"
        read -rp "Your choice: " PICKCHOICE
        if [[ "$PICKCHOICE" = "x" ]]; then
            PICKCHOICE=""
            return
        fi
        if [[ ! -d "$1/$PICKCHOICE" ]]; then
            echo "Wrong selection"
            PICKCHOICE=""
            PRESS_ENTER
        else
            return 0
        fi
    done
}


# Tries to mount chosen file
TRY_MOUNT() {
    # $1 - File to mount
    # $2 - Directory to mount file into
    echo "Trying to mount $(basename "$1")"
    ROOT_EXECUTE "modprobe loop"
    mkdir -p "$2"
    echo "Mounting file: '$(basename "$1")'"
    ROOT_EXECUTE "mount -t auto -o loop $1 $2"
    if [[ $? -eq 0 ]]; then
        echo "Success!"
        return 0
    else
        echo "Failed!" >&2
        ROOT_EXECUTE "umount $2"
        return 1
    fi
}

# Removes ACTIVE_PROJECT
DEL_PROJECT() {
    echo "Cleaning $ACTIVE_PROJECT"
    rm -rf "$ACTIVE_PROJECT"
    ACTIVE_PROJECT=""
}

# Deletes chosen project.
DEL_PROJECTS() {
    local PROJECT
    while true; do
        PRINT_BANNER_NEUTRAL
        echo "Which project do you want to delete?"
        echo "================"
        find . -type d -name "PROJECT_*"
        echo "================"
        read -r -e -p "Which project? [Press <Enter> to abort]: " PROJECT
        if [ ! "$PROJECT" ]; then
            break
        fi

        if [ ! -d "$PROJECT" ]; then
            echo "Cannot find project: $PROJECT" >&2
            read -rp "Press <Enter> to continue... " junk
            continue
        fi

        echo "Removing project: ${PROJECT}"
        rm -rf "${PROJECT}"
        echo "Done!"
        sleep 1
        continue
    done
}

# Creates new project
SET_NEWPROJECT() {
    local PROJECT
    PRINT_BANNER_NEUTRAL
    echo "Before you begin, you must specify the project you want to create"
    echo
    echo "b - Create a Bare Bones project"
    echo "i - Create a ZIP-flashable ROM from stock partition image(s)"
    echo "z - Create a ZIP-flashable ROM from other ZIP-flashable ROM"
    echo
    echo "x - Abort!"
    read -rp "Project type [B/i/z]: " CHOICE
    if [ "$CHOICE" = "x" ] || [ "$CHOICE" = "X" ]; then
        return
    fi
    read -rp "Project name (OK to leave empty): PROJECT_" NAME

    if [ ! "${NAME}" ]; then
        NAME="$(date '+%m%d%y_%H%M%S')"
    fi
    ACTIVE_PROJECT="PROJECT_${NAME}"
    case "$CHOICE" in
        i|I) NEWPROJECT_STOCK ;;
        z|Z) NEWPROJECT_ZIP ;;
        b|B) NEWPROJECT_BARE ;;
    esac
}

# Sets ACTIVE_PROJECT
SET_PROJECT() {
    echo
    echo "You currently don't have any active project set"
    echo "What do you wanna do?"
    echo
    echo "n - Create a new project"
    echo "e - Use existing project"
    echo "d - Delete existing project"
    echo "x - Exit"
    read -rp "Your choice: " CHOICE
    case "$CHOICE" in
        n|N) SET_NEWPROJECT ;;
        e|E) SET_OLDPROJECT ;;
        d|D) DEL_PROJECTS ;;
        *) exit 0 ;;
    esac
}

# Sets old project as active one
SET_OLDPROJECT() {
    PRINT_BANNER
    local COUNT=0
    local LASTFOUND=""
    echo "Searching for projects you've created in the past..."
    echo "=-=-=-=-=-=-=-=-="
    while read -r line; do
        ((COUNT++))
        LASTFOUND="$line"
        basename "$LASTFOUND"
    done < <(find . -type d -iname "PROJECT_*") # Avoid a subshell, because we must remember variables
    echo "=-=-=-=-=-=-=-=-="
    echo "Found total of $COUNT projects"
    if [[ "$COUNT" -eq 1 ]]; then
        # If we have only one project, then we can skip the menu (save some time)
        ACTIVE_PROJECT="$(basename "$LASTFOUND")"
        return 0
    fi
    echo
    read -rp "Your selected project ['x' to go back]: " CHOICE
    case "$CHOICE" in
        x|X) return ;;
        *)
            CHOICE="$(basename "$CHOICE")"
            if [[ -d "$CHOICE" ]]; then
                ACTIVE_PROJECT="$CHOICE"
            else
                echo "Invalid selection"
                PRESS_ENTER
            fi
        ;;
    esac
}

# Handles image files
HANDLE_IMG() {
    local IMGFILE DEST INFO
    IMGFILE="$1"
    DESTFILE="$2"

    # Check file / info
    INFO="$(od -A n -h -N 5 "$1" | sed 's/ //g')"

    if [[ "$INFO" = "ff3aed260001" ]]; then
        echo "Type: Sparse image file"
        if [[ ! -x "$TEMPDIR/simg2img" ]]; then
            echo "Compiling simg2img..."
            gcc -Os -j32 "$TOOLSDIR/simg2img/sparse_crc32.c" \
            "$TOOLSDIR/simg2img/simg2img.c" -o "$TEMPDIR/simg2img"
        fi
        echo "Converting sparse image to image..."
        ./"$TEMPDIR"/simg2img "$IMGFILE" "${DESTFILE}"
        if [[ $? -ne 0 ]]; then
            echo "Conversion failed" >&2
            return 1
        else
            echo "Conversion success!"
            return 0
        fi
    else
        echo "Unknown image type: $INFO" >&2
        echo "Skipping..." >&2
        cp "$IMGFILE" "${DESTFILE}"
        return
    fi
}

# Creates a new bare project
NEWPROJECT_BARE() {
    mkdir -p "$ACTIVE_PROJECT/system"
    BUILD_META_INF
    BUILD_UPDATER_SCRIPT
}

# Creates a new stock image-based project
NEWPROJECT_STOCK() {
    PRINT_BANNER_NEUTRAL
    echo "To create a ROM from stock partition images, make sure that you have:"
    echo
    echo "[REQUIRED] system.img - Partition image for /system partition"
    echo "[REQUIRED] boot.img - Raw kernel image for boot block"
    echo "[OPTIONAL] cache.img - Partition image for /cache partition"
    echo "[OPTIONAL] modem.bin - Raw modem image for modem block"
    echo
    echo "Please notice that some ROMs may have other requirements, for eg: requiring 'cache.img' and not optional"

    local READY=0
    while [[ $READY -eq 0 ]]; do
        echo
        echo "Please fill a path for your system.img file"
        echo "Potential candidates:"
        echo "=-=-=-=-=-=-=-=-="
        find base_drops/ -type f -iname "*system*"
        echo "=-=-=-=-=-=-=-=-="
        read -r -e -p "system.img: " SYSTEMIMG

        echo
        echo "Please fill a path for your boot.img file"
        echo "Potential candidates:"
        echo "=-=-=-=-=-=-=-=-="
        find base_drops/ -type f -iname "*boot*"
        echo "=-=-=-=-=-=-=-=-="
        read -r -e -p "boot.img: " BOOTIMG

        echo
        echo "Please fill a path for your cache.img file. Leave empty if you don't have one"
        echo "Potential candidates:"
        echo "=-=-=-=-=-=-=-=-="
        find base_drops/ -type f -iname "*cache*"
        echo "=-=-=-=-=-=-=-=-="
        read -r -e -p "cache.img: " CACHEIMG

        echo
        echo "Please fill a path for your modem.bin file. Leave empty if you don't have one"
        echo "Potential candidates:"
        echo "=-=-=-=-=-=-=-=-="
        find base_drops/ -type f -iname "*modem*"
        echo "=-=-=-=-=-=-=-=-="
        read -r -e -p "modem.bin: " MODEMIMG

        if [[ -f "$SYSTEMIMG" && -f "$BOOTIMG" ]] && \
        ([[ -z "$CACHEIMG" || -f "$CACHEIMG" ]]) && \
        ([[ -z "$MODEMIMG" || -f "$MODEMIMG" ]]); then
            READY=1
        else
            echo "Some of your files don't exist"
            PRESS_ENTER
        fi
    done

    echo "Creating $ACTIVE_PROJECT"
    mkdir -p "$ACTIVE_PROJECT/system"

    # KERNEL
    cp "$BOOTIMG" "$ACTIVE_PROJECT/boot.img"

    # SYSTEM
    HANDLE_IMG "$SYSTEMIMG" "$ACTIVE_PROJECT/system.img"
    if [ $? = "1" ]; then
        echo "Failed to copy/convert image file!" >&2
        PRESS_ENTER
        DEL_PROJECT
        return 1
    fi
    TRY_MOUNT "$ACTIVE_PROJECT/system.img" "/tmp/kitch.loop" || (DEL_PROJECT; return 1)
    echo "Extracting everything from mounted system partition..."
    ROOT_EXECUTE "cp -R /tmp/kitch.loop/* $ACTIVE_PROJECT/system/"
    ROOT_EXECUTE "umount /tmp/kitch.loop"
    rm -f "$ACTIVE_PROJECT/system.img"

    # CACHE
    if [[ ! -z "$CACHEIMG" ]]; then
        cp "$CACHEIMG" "$ACTIVE_PROJECT/cache.img"
        TRY_MOUNT "$ACTIVE_PROJECT/cache.img" "/tmp/kitch.loop"
        if [[ -f "/tmp/H4X0RLOOP/recovery/sec_csc.zip" ]]; then
            echo "Found common Samsung sec_csc.zip file, extracting it and merging with the project"
            ROOT_EXECUTE "unzip -q /tmp/H4X0RLOOP/recovery/sec_csc.zip -d $ACTIVE_PROJECT/"
        else
            echo "Could not detect any known cache format"
            echo "This is typical when cache doesn't contain any valuable files, such as sec_csc.zip in case of Samsung ROMs"
            echo "Extract everything you need from /tmp/kitch.loop/ before going to the next step"
            PRESS_ENTER
        fi
        ROOT_EXECUTE "umount /tmp/kitch.loop"
        rm -f "$ACTIVE_PROJECT/cache.img"
    fi

    # MODEM
    if [[ ! -z "$MODEMIMG" ]]; then
        cp "$MODEMIMG" "$ACTIVE_PROJECT/modem.bin"
    fi

    # Fix permissions
    ROOT_EXECUTE "chown -hR $CUSER.$CUSER $ACTIVE_PROJECT"
    ROOT_EXECUTE "chmod -R 755 $ACTIVE_PROJECT"

    # Generate required files
    rm -rf "$ACTIVE_PROJECT/META-INF"   # In case we have any bloat from sec_csc.zip or similar
    BUILD_META_INF
    BUILD_UPDATER_SCRIPT
    PRESS_ENTER
    SET_KERNEL
    SET_MODEM
}

# Creates a new zip-based project
NEWPROJECT_ZIP() {
    PRINT_BANNER_NEUTRAL
    read -r -e -p "Location of ZIP-file: " SRC_ZIP
    if [ ! -f "$(realpath "$SRC_ZIP" 2>/dev/null)" ]; then
        echo "Cannot find ZIP file: $(basename "$SRC_ZIP")" >&2
        read -rp "Press [Enter] to continue..." junk
        return 1
    fi
    echo "Creating barebones project... [TEMPLATE]"
    NEWPROJECT_BARE

    echo "Extracting ZIP file..."
    unzip -o "$SRC_ZIP" -d "$ACTIVE_PROJECT"

    echo "Fixing permissions..."
    # Fix permissions
    ROOT_EXECUTE "chown -hR $CUSER.$CUSER $ACTIVE_PROJECT"
    ROOT_EXECUTE "chmod -R 755 $ACTIVE_PROJECT"

    echo "Generating required files..."
    # Generate required files
    rm -rf "$ACTIVE_PROJECT/META-INF"   # In case we have any bloat from sec_csc.zip or similar
    BUILD_META_INF
    BUILD_UPDATER_SCRIPT
    PRESS_ENTER
    SET_KERNEL
    SET_MODEM
    echo "Done!"
}

# Sets kernel
SET_KERNEL() {
    if [[ -f "$ACTIVE_PROJECT/boot.img" ]] && ([[ "$(grep -qi "boot.img" "$ACTIVE_PROJECT/$META_INF/updater-script"; echo $?)" \
    -ne 0 || "$(grep -qi "/tmp/invalid_kernel_path" "$ACTIVE_PROJECT/$META_INF/updater-script"; echo $?)" -eq 0 ]]); then
        PRINT_BANNER_NEUTRAL
        echo "WARNING! Kernel has been found but there's no path in the current updater-script"
        echo "This is typical when you're converting stock image partition to ZIP-flashable ROM"
        local MODEL
        MODEL="$(grep -i "ro.product.device=" "$ACTIVE_PROJECT/system/build.prop" | head -n 1 | cut -d'=' -f2)"
        if [[ -z "$MODEL" ]]; then
            echo "ERROR: Could not detect ROM model, setting of kernel failed"
            PRESS_ENTER
            return 1
        fi
        echo
        echo "Detected ROM model: $MODEL"
        if [[ -f "product/$MODEL/KERNEL" ]]; then
            KERNELPATH="$(cat "product/$MODEL/KERNEL")"
            echo "Based on detected ROM model and our little database, your kernel path should be: $KERNELPATH"
        else
            echo "This model does not yet exist in our database. Please fill your kernel path manually"
            echo
            echo "Example for I9300/m0 (Samsung Galaxy S3): /dev/block/mmcblk0p5"
            echo "Example for N9005/hlte (Samsung Note 3): /dev/block/mmcblk0p14"
            echo "Example for E960/mako (LG Nexus 4): /dev/block/platform/msm_sdcc.1/by-name/boot"
            echo
            echo "MAKE SURE THAT THE PATH IS CORRECT, OVERWRITING WRONG PATHS MAY LEAD TO SOFT AND HARD BRICKS"
            read -rp "Kernel path for your device: " KERNELPATH
        fi
        SED_CHANGE_WORD "/tmp/invalid_kernel_path" "$KERNELPATH" "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_KERNEL" "^"
        echo
        echo "The final effect is:"
        echo "=-=-=-=-=-=-=-=-="
        cat "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_KERNEL"
        echo
        echo "=-=-=-=-=-=-=-=-="
        echo "Make sure that the command is correct"
        echo "If you need to apply any changes to the generated command, please edit $ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_KERNEL before going to the next step"
        PRESS_ENTER
    fi
}

# Sets modem
SET_MODEM() {
    if [[ -f "$ACTIVE_PROJECT/modem.bin" ]] && \
    ([[ "$(grep -qi "modem.bin" "$ACTIVE_PROJECT/$META_INF/updater-script"; echo $?)" -ne 0 || \
    "$(grep -qi "/tmp/invalid_modem_path" "$ACTIVE_PROJECT/$META_INF/updater-script"; echo $?)" -eq 0 ]]); then
        PRINT_BANNER_NEUTRAL
        echo "WARNING! Modem has been found but there's no path in the current updater-script"
        echo "This is typical when you're converting stock image partition to ZIP-flashable ROM"
        local MODEL
        MODEL="$(grep -i "ro.product.device=" "$ACTIVE_PROJECT/system/build.prop" | head -n 1 | cut -d'=' -f2)"
        if [[ -z "$MODEL" ]]; then
            echo "ERROR: Could not detect ROM model, setting of modem failed"
            PRESS_ENTER
            return 1
        fi
        echo "Detected ROM model: $MODEL"
        if [[ -f "product/$MODEL/MODEM" ]]; then
            MODEMPATH="$(cat "product/$MODEL/MODEM")"
            echo "Based on detected ROM model and our database, your modem path should be: $MODEMPATH"
        else
            echo "This model doesn't exist in our database. Please fill your modem path manually"
            echo "Please note that some models are don't flashing modem via recovery, in such case you should use"
            echo "generic 'NULL' word in this question"
            echo
            echo "Example for I9300/m0 (Samsung Galaxy S3): /dev/block/mmcblk0p7"
            echo "Example for N9005/hlte (Samsung Note 3): NULL"
            echo "Example for E960/mako (LG Nexus 4): /dev/block/platform/msm_sdcc.1/by-name/modem"
            echo
            echo "MAKE SURE THAT THE PATH IS CORRECT, OVERWRITING WRONG PATHS MAY LEAD TO SOFT AND HARD BRICKS"
            read -rp "Modem path for your device: " MODEMPATH
        fi
        if [[ "$MODEMPATH" = "NULL" ]]; then
            echo "Your device doesn't support flashing a modem through recovery, your modem path is 'NULL'"
            rm -f "$ACTIVE_PROJECT/modem.bin" "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_MODEM"
        else
            SED_CHANGE_WORD "/tmp/invalid_modem_path" "$MODEMPATH" "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_MODEM" "^"
            echo
            echo "The final effect is:"
            echo "=-=-=-=-=-=-=-=-="
            cat "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_MODEM"
            echo
            echo "=-=-=-=-=-=-=-=-="
            echo "Make sure that the command is correct"
            echo "If you need to apply any changes to the generated command, please edit $ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_MODEM before going to the next step"
        fi
        PRESS_ENTER
    fi
}

# Generate generic META-INF
BUILD_META_INF() {
    mkdir -p "$ACTIVE_PROJECT/$META_INF"
    cp product/_generic/update-binary "$ACTIVE_PROJECT/$META_INF/update-binary"
    for UPDATER_SCRIPT in "product/_generic/updater-scripts/"*; do
        cp "$UPDATER_SCRIPT" "$ACTIVE_PROJECT/$META_INF/"
    done
}

# Merges updater-scripts from $1 to our ACTIVE_PROJECT
UPDATER_SCRIPT_ADD() {
    local FOLDER="$1"
    local FILE=""
    for UPDATER_SCRIPT in "$FOLDER/updater-script-"*; do
        FILE="$(basename "$UPDATER_SCRIPT")"
        {
            echo # This is to ensure that we have a new line BEFORE appending"
            cat "$UPDATER_SCRIPT"
            echo # This is to ensure that we have a new line AFTER appending"
        } >> "$ACTIVE_PROJECT/$META_INF/$FILE"
        sed -i '/^$/d' "$ACTIVE_PROJECT/$META_INF/$FILE" # This removes safety lines added above
    done
}

# Reverts merge of updater-scripts from $1 in our ACTIVE_PROJECT
UPDATER_SCRIPT_DEL() {
    local FOLDER="$1"
    local FILE=""
    for UPDATER_SCRIPT in "$FOLDER/updater-script-"*; do
        # TODO: I know that this is slow and inefficient way, however at least I can prove that it's stable and secure
        # If anybody manages to delete lines from $ACTIVE_PROJECT/$META_INF/$FILE, which exist in $UPDATER_SCRIPT, please contribute! :)
        # Unfortunately I failed using sed, so I'm out of better ideas :(
        FILE="$(basename "$UPDATER_SCRIPT")"
        echo -n "" > "$ACTIVE_PROJECT/$FILE"
        while read -r line; do
            if [[ "$(grep -q "$line" "$UPDATER_SCRIPT"; echo $?)" -eq 1 ]]; then
                echo "$line" >> "$ACTIVE_PROJECT/$FILE"
            fi
        done < "$ACTIVE_PROJECT/$META_INF/$FILE"
        mv -f "$ACTIVE_PROJECT/$FILE" "$ACTIVE_PROJECT/$META_INF/$FILE"
    done
}

# Builds final updater-script from our segments
BUILD_UPDATER_SCRIPT() {
    local HEADER=""
    echo -n "" > "$ACTIVE_PROJECT/$META_INF/updater-script"
    for UPDATER_SCRIPT in "$ACTIVE_PROJECT/$META_INF/updater-script-"*; do
        HEADER="# $(basename "$UPDATER_SCRIPT")"
        {
            echo # This is to ensure that we have a new line BEFORE appending"
            echo "$HEADER"
            cat "$UPDATER_SCRIPT"
            echo # This is to ensure that we have a new line AFTER appending"
        } >> "$ACTIVE_PROJECT/$META_INF/updater-script"
    done
    sed -i '/^$/d' "$ACTIVE_PROJECT/$META_INF/updater-script" # This removes safety lines added above
    GREP_DELETE_WORD "/tmp/invalid" "$ACTIVE_PROJECT/$META_INF/updater-script" "^" # This is to ensure that we won't pollute our updater-script with invalid paths for kernel or modem
}

# Removes invalid generic permissions
FIX_PERMISSIONS() {
    echo "Right now you're using generic list of permissions based on multiple devices"
    echo "It's usually a good idea to remove invalid permissions, by invalid I mean permissions to non-existent files or folders"
    read -rp "Do you want to remove invalid permissions? [Y/n]: " CHOICE
    case "$CHOICE" in
        n|N) ;;
        *)
            cp "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_PERMISSIONS" "$ACTIVE_PROJECT/updater-script-TEMP"
            rm -f "$ACTIVE_PROJECT/updater-script-TEMP-LIST"
            while read -r perm; do
                perm="$(echo "$perm" | cut -d'"' -f2)"
                if [[ -z "$perm" ]]; then
                    continue
                elif [[ ! -e "$ACTIVE_PROJECT$perm" ]]; then
                    echo "$perm" >> "$ACTIVE_PROJECT/updater-script-TEMP-LIST"
                    grep -v "$perm" "$ACTIVE_PROJECT/updater-script-TEMP" > "$ACTIVE_PROJECT/updater-script-TEMP2"
                    mv -f "$ACTIVE_PROJECT/updater-script-TEMP2" "$ACTIVE_PROJECT/updater-script-TEMP"
                fi
            done < "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_PERMISSIONS"
            if [[ ! -f "$ACTIVE_PROJECT/updater-script-TEMP-LIST" ]]; then
                echo "No invalid permissions found, your updater-script is clean!"
                rm -f "$ACTIVE_PROJECT/updater-script-TEMP"
            else
                echo "OK, permissions for following files have been removed from your updater-script: "
                echo "-=-= REMOVED PERMISSIONS START =-=-"
                cat "$ACTIVE_PROJECT/updater-script-TEMP-LIST"
                echo "-=-= REMOVED PERMISSIONS EOF =-=-"
                rm -f "$ACTIVE_PROJECT/updater-script-TEMP-LIST"
                mv -f "$ACTIVE_PROJECT/updater-script-TEMP" "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_PERMISSIONS"
            fi
            PRESS_ENTER
    esac
}

# Removes invalid generic symlinks, adds local ones
FIX_SYMLINKS() {
    echo "Right now you're probably using generic list of symlinks based on multiple devices"
    echo "It's usually a good idea to remove invalid symlinks, by invalid I mean symlinks to non-existent files or folders"
    read -rp "Do you want to remove invalid symlinks? [Y/n]: " CHOICE
    case "$CHOICE" in
        n|N) ;;
        *)
            cp "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_SYMLINKS" "$ACTIVE_PROJECT/updater-script-TEMP"
            rm -f "$ACTIVE_PROJECT/updater-script-TEMP-LIST"
            local SYMLINKDIR=""
            while read -r SYMLINK; do
                SYMLINKDIR="$(dirname "$(echo "$SYMLINK" | cut -d'"' -f4)")"
                SYMLINK="$(echo "$SYMLINK" | cut -d'"' -f2)"
                # If symlink is empty, continue
                if [[ -z "$SYMLINK" ]]; then
                    continue
                # If symlink is absolute symlink and doesn't start with /system, continue, we can't track directories like /firmware or /data
                elif [[ "$SYMLINK" == /* && "$SYMLINK" != /system* ]]; then
                    continue
                # We may have relative symlink such as /system/bin/dd -> toolbox, or absolute symlink such as /system/bin/busybox -> /system/xbin/buysbox
                elif [[ ! -e "$ACTIVE_PROJECT$SYMLINKDIR/$SYMLINK" && ! -e "$ACTIVE_PROJECT$SYMLINK" ]]; then
                    echo "$SYMLINK" >> "$ACTIVE_PROJECT/updater-script-TEMP-LIST"
                    grep -v "$SYMLINK" "$ACTIVE_PROJECT/updater-script-TEMP" > "$ACTIVE_PROJECT/updater-script-TEMP2"
                    mv -f "$ACTIVE_PROJECT/updater-script-TEMP2" "$ACTIVE_PROJECT/updater-script-TEMP"
                fi
            done < "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_SYMLINKS"
            if [[ ! -f "$ACTIVE_PROJECT/updater-script-TEMP-LIST" ]]; then
                echo "No invalid symlinks found, your updater-script is clean!"
                rm -f "$ACTIVE_PROJECT/updater-script-TEMP"
            else
                echo "OK, symlinks for following files have been removed from your updater-script: "
                echo "-=-= REMOVED SYMLINKS START =-=-"
                cat "$ACTIVE_PROJECT/updater-script-TEMP-LIST"
                echo "-=-= REMOVED SYMLINKS EOF =-=-"
                rm -f "$ACTIVE_PROJECT/updater-script-TEMP-LIST"
                mv -f "$ACTIVE_PROJECT/updater-script-TEMP" "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_SYMLINKS"
            fi
            PRESS_ENTER
            echo
    esac

    echo "We can also add local symlinks from your project, these are available only if your project is based on stock image and contains symlinks inside"
    echo "It's usually a very good idea to add local symlinks, if they're available, in worst case we won't be able to find anything"
    read -rp "Do you want to include local symlinks? [Y/n]: " CHOICE
    case "$CHOICE" in
        n|N) ;;
        *)
            local TARGET=""
            local REALPATH=""
            rm -f "$ACTIVE_PROJECT/updater-script-TEMP-LIST" "$ACTIVE_PROJECT/updater-script-TEMP-FOUNDSYMLINKS"
            local MAGIC="0"
            find "$ACTIVE_PROJECT/" -type l | sort | while read -r SYMLINK; do
                TARGET="$(readlink "$SYMLINK")"
                if [[ "$MAGIC" -eq 0 ]]; then
                    # Find proper path
                    for ((I=1; MAGIC==0; I++)); do
                        if [[ "$(echo "$SYMLINK" | cut -d'/' -f$I)" = "$ACTIVE_PROJECT" ]]; then
                            MAGIC="$((I+1))" # We found where ACTIVE_PROJECT is, so now we can set MAGIC right for the next folder
                        fi
                    done
                fi
                REALPATH="/"
                REALPATH+="$(echo "$SYMLINK" | cut -d'/' -f$MAGIC-)"
                echo "symlink(\"$TARGET\", \"$REALPATH\");" >> "$ACTIVE_PROJECT/updater-script-TEMP-FOUNDSYMLINKS"
                echo "$REALPATH -> $TARGET" >> "$ACTIVE_PROJECT/updater-script-TEMP-LIST"
            done
            if [[ ! -f "$ACTIVE_PROJECT/updater-script-TEMP-LIST" ]]; then
                echo "No local symlinks found, it looks like your build is not based on stock image or local symlinks have been added already"
            else
                echo "Found symlinks:"
                echo "-=-= ADDED SYMLINKS START =-=-"
                cat "$ACTIVE_PROJECT/updater-script-TEMP-LIST"
                echo "-=-= ADDED SYMLINKS EOF =-=-"
                rm -f "$ACTIVE_PROJECT/updater-script-TEMP-LIST"
                PRESS_ENTER
                echo "We managed to find local symlinks. Therefore, if the list is complete we don't need to include all generic symlinks, but just found ones"
                echo "This will result in exact 1:1 copy of all symlinks which are available in system.img, without adding extra ones"
                echo "It's usually a very good idea to keep only found symlinks instead of the whole list, but you may also want to append them to the generic databse instead of making 1:1 copy"
                read -rp "Do you want to include only symlinks that were found? [Y/n]: " CHOICE
                case "$CHOICE" in
                    n|N) echo "OK, your symlinks have been appended to the generic list"; cat "$ACTIVE_PROJECT/updater-script-TEMP-FOUNDSYMLINKS" >> "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_SYMLINKS"; rm -f "$ACTIVE_PROJECT/updater-script-TEMP-FOUNDSYMLINKS" ;;
                    *) echo "OK, updater-script now uses only symlinks that were found"; mv -f "$ACTIVE_PROJECT/updater-script-TEMP-FOUNDSYMLINKS" "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_SYMLINKS"
                esac
            fi
            PRESS_ENTER
            echo
    esac

    echo "Please wait..."
    # Remove duplicated symlinks and sort them
    sort -u < "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_SYMLINKS" > "$ACTIVE_PROJECT/updater-script-TEMP"
    mv -f "$ACTIVE_PROJECT/updater-script-TEMP" "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_SYMLINKS"

    # Remove local symlinks, we don't need them to pollute our ROM
    find "$ACTIVE_PROJECT/" -type l -delete

    # Remove empty lines, if any
    sed -i '/^$/d' "$ACTIVE_PROJECT/$META_INF/$UPDATER_SCRIPT_SYMLINKS"
}

# Extracts the kernel
KERNEL_EXTRACT() {
    if [[ ! -d "$ACTIVE_PROJECT/kernel" ]]; then
        if [[ ! -x "$TEMPDIR/mkbootimg" ]]; then
            cd "$TOOLSDIR/mkbootimg"
            make
            if [[ ! -x mkbootimg || ! -x unpackbootimg ]]; then
                echo "ERROR! Something went wrong when trying to compile mkbootimg..."
                PRESS_ENTER
                return 1
            fi
            mv mkbootimg "../../$TEMPDIR/mkbootimg"
            mv unpackbootimg "../../$TEMPDIR/unpackbootimg"
            make clean
            cd ../..
        fi

        if [[ ! -L "$TOOLSDIR/mtk-tools/mkbootimg" ]]; then
            rm -f "$TOOLSDIR/mtk-tools/mkbootimg"
            ln -s "../../$TEMPDIR/mkbootimg" "$TOOLSDIR/mtk-tools/mkbootimg"
        fi

        if [[ -f "$ACTIVE_PROJECT/boot.img" ]]; then
            mkdir -p "$ACTIVE_PROJECT/kernel"
            "$TEMPDIR/unpackbootimg" -i "$ACTIVE_PROJECT/boot.img" -o "$ACTIVE_PROJECT/kernel"
            mkdir -p "$ACTIVE_PROJECT/kernel/boot.img-ramdisk"
            if [[ -f "$ACTIVE_PROJECT/kernel/boot.img-ramdisk.gz" ]]; then
                # Detect compression algorithm
                if [[ "$(gunzip -t "$ACTIVE_PROJECT/kernel/boot.img-ramdisk.gz" >/dev/null 2>&1; echo $?)" -eq 0 ]]; then
                    # GZIP
                    CBIN="gzip -9"
                    DBIN="gunzip -c"
                elif [[ "$(lzop -t "$ACTIVE_PROJECT/kernel/boot.img-ramdisk.gz" >/dev/null 2>&1; echo $?)" -eq 0 ]]; then
                    # LZO
                    CBIN="lzop -9"
                    DBIN="lzop -dc"
                elif [[ "$(xz -t "$ACTIVE_PROJECT/kernel/boot.img-ramdisk.gz" >/dev/null 2>&1; echo $?)" -eq 0 ]]; then
                    # XZ
                    CBIN="xz -9"
                    DBIN="xz -dc"
                elif [[ "$(lzma -t "$ACTIVE_PROJECT/kernel/boot.img-ramdisk.gz" >/dev/null 2>&1; echo $?)" -eq 0 ]]; then
                    # LZMA
                    CBIN="lzma -9"
                    DBIN="lzma -dc"
                else
                    echo "WARNING: Could not detect any known format of the ramdisk!"
                    KERNEL_ABORT
                    echo "INFO: Trying to unpack the kernel as MTK..."
                    mkdir -p "$ACTIVE_PROJECT/kernel"
                    cd "$ACTIVE_PROJECT/kernel"
                    local MTK_PROBE
                    MTK_PROBE="$(../../$TOOLSDIR/mtk-$TOOLSDIR/unpack-MTK.pl "../boot.img" >/dev/null 2>&1; echo $?)"
                    cd ../..
                    if [[ "$MTK_PROBE" -eq 0 ]]; then
                        echo "INFO: Success!"
                        CBIN="mtk"
                        DBIN="mtk"
                    else
                        echo "ERROR: Could not find any valid method to unpack this kernel. Either it's not valid,"
                        echo "or the kitchen doesn't know how to deal with it."
                        echo ""
                        KERNEL_ABORT
                        PRESS_ENTER
                        return 1
                    fi
                fi
                echo "$CBIN" > "$ACTIVE_PROJECT/kernel/AndyH4x0r-compression-method" # Store for future use, if user decides to shut down the kitchen
                if [[ "$CBIN" != "mtk" && "$DBIN" != "mtk" ]]; then
                    cd "$ACTIVE_PROJECT/kernel/boot.img-ramdisk"
                    $DBIN ../boot.img-ramdisk.gz | cpio -i
                    cd ../../..
                fi
            fi
        else
            echo "ERROR: No kernel could be found!"
            PRESS_ENTER
            return 1
        fi
    fi
}

# Repacks the kernel from previously extracted one
KERNEL_REPACK() {
    local EXTRA=()
    if [[ -d "$ACTIVE_PROJECT/kernel" ]]; then
        if [[ -d "$ACTIVE_PROJECT/kernel/boot.img-ramdisk" ]]; then
            if [[ -z "$CBIN" && -f "$ACTIVE_PROJECT/kernel/AndyH4x0r-compression-method" ]]; then
                CBIN="$(cat "$ACTIVE_PROJECT/kernel/AndyH4x0r-compression-method")" # Load compression method if we need it and have it stored
            elif [[ -z "$CBIN" ]]; then
                echo "ERROR: Can't decide which compression method to use!"
                KERNEL_ABORT
                PRESS_ENTER
                return 1
            fi
            local SUCCESS=1
            if [[ "$CBIN" != "mtk" ]]; then
                cd "$ACTIVE_PROJECT/kernel/boot.img-ramdisk"
                find . | cpio -o -H newc | $CBIN > ../boot.img-ramdisk-NEW.gz
                cd ../../..
                if [[ -f "$ACTIVE_PROJECT/kernel/boot.img-dtb" ]]; then
                    EXTRA+=(--dt "$ACTIVE_PROJECT/kernel/boot.img-dtb")
                fi
                SUCCESS="$(
                    "$TEMPDIR/mkbootimg" --kernel "$ACTIVE_PROJECT/kernel/boot.img-zImage" \
                    --ramdisk "$ACTIVE_PROJECT/kernel/boot.img-ramdisk-NEW.gz" \
                    --base "$(cat "$ACTIVE_PROJECT/kernel/boot.img-base")" \
                    --cmdline "$(cat "$ACTIVE_PROJECT/kernel/boot.img-cmdline")" \
                    --kernel_offset "$(cat "$ACTIVE_PROJECT/kernel/boot.img-kerneloff")" \
                    --pagesize "$(cat "$ACTIVE_PROJECT/kernel/boot.img-pagesize")" \
                    --ramdisk_offset "$(cat "$ACTIVE_PROJECT/kernel/boot.img-ramdiskoff")" \
                    --tags_offset "$(cat "$ACTIVE_PROJECT/kernel/boot.img-tagsoff")" \
                    "${EXTRA[@]}" \
                    -o "$ACTIVE_PROJECT/kernel/temp.img" >/dev/null 2>&1
                    echo $?
                )"
            else
                cd "$ACTIVE_PROJECT/kernel"
                SUCCESS="$(
                    ../../tools/mtk-tools/repack-MTK.pl -boot \
                    boot.img-kernel.img \
                    boot.img-ramdisk \
                    temp.img >/dev/null 2>&1
                    echo $?
                )"
                cd ../..
            fi
            if [[ "$SUCCESS" -eq 0 ]]; then
                mv "$ACTIVE_PROJECT/kernel/temp.img" "$ACTIVE_PROJECT/boot.img"
                KERNEL_ABORT # This is actually used for cleaning only
                return 0
            else
                echo "ERROR: Something went wrong! Error code: $SUCCESS"
                KERNEL_ABORT
                PRESS_ENTER
                return 1
            fi
        else
            echo "ERROR: Could not find the ramdisk!"
            KERNEL_ABORT
            PRESS_ENTER
            return 1
        fi
    fi
}

# Aborts kernel repacking - performs cleaning
KERNEL_ABORT() {
    rm -rf "$ACTIVE_PROJECT/kernel"
    rm -f "$ACTIVE_PROJECT/temp.img"
}

# Adds kernel's Init.d
INITD() {
    if [[ -f "$ACTIVE_PROJECT/kernel/boot.img-ramdisk/init.rc" ]]; then
        sed -i -e '0,/class_start /s//start sysinit\n\n    class_start /' "$ACTIVE_PROJECT/kernel/boot.img-ramdisk/init.rc"
        sed -i -e 's/service media /service sysinit \/system\/bin\/logwrapper \/system\/xbin\/busybox run-parts \/system\/etc\/init.d\n    disabled\n    oneshot\n\nservice media /' "$ACTIVE_PROJECT/kernel/boot.img-ramdisk/init.rc"
        cp -R files/initd/system/* "$ACTIVE_PROJECT/system/"
        UPDATER_SCRIPT_ADD "files/initd/updater-scripts"
    else
        echo "ERROR, no init.rc found?!"
        rm -rf kernel
        PRESS_ENTER
        return 1
    fi
}

# Builds ROM
BUILD() {
    clear
    echo "Building ROM"
    PRINT_LINE
    local EXPERT=0
    for ARG in "$@"; do
        case "$ARG" in
            "EXPERT")
                EXPERT=1
        esac
    done
    if [[ "$EXPERT" -eq 0 ]]; then
        FIX_PERMISSIONS
        FIX_SYMLINKS
        BUILD_UPDATER_SCRIPT
        SED_CHANGE_WORD "313371337" "$(find "$ACTIVE_PROJECT/system" -type f | wc -l)" \
        "$ACTIVE_PROJECT/$META_INF/updater-script"
        PRESS_ENTER
        echo "Sometimes kitchen may produce an incorrect updater-script file, that's why you're asked to review updater-script and eventually fix it if needed BEFORE building ROM"
        echo "Updater-script is based on so-called 'segments' available in the same directory - $META_INF"
        echo "Are you ready?"
        PRESS_ENTER
        echo "=-= UPDATER-SCRIPT START =-="
        cat "$ACTIVE_PROJECT/$META_INF/updater-script"
        echo "=-= UPDATER-SCRIPT EOF =-="
        read -rp "Are you REALLY sure that above updater-script is correct? ESPECIALLY block-based paths? [Y/n]: " CHOICE
        case "$CHOICE" in
            n|N)
                echo "OK, correct your updater-script and/or it's segments and come back when you're finished"
                PRESS_ENTER
                return 0
        esac
    fi
    local COMPLEVEL="1"
    echo
    echo "Which compression level do you want to use?"
    echo "0 - Store (fastest method, no compression at all)"
    echo "1 - Fastest (fastest type of compression, this is default suggested mode)"
    echo "9 - Best (slowest, maximum compression)"
    echo "You can also type any number between 0-9"
    read -rp "CHOICE: " CHOICE
    case "$CHOICE" in
        [0-9]) COMPLEVEL="$CHOICE"
    esac
    cd "$ACTIVE_PROJECT"
    zip -ry -"$COMPLEVEL" "$ACTIVE_PROJECT.zip" . -x "$META_INF/updater-script-"*
    cd ..
    mkdir -p OUTPUT
    mv -f "$ACTIVE_PROJECT/$ACTIVE_PROJECT.zip" "OUTPUT/$ACTIVE_PROJECT.zip"
    echo "Done, your ROM is available in OUTPUT/$ACTIVE_PROJECT.zip"
    read -rp "Rename it? [N/y]: " CHOICE
    case "$CHOICE" in
        y|Y)
            read -rp "New name: " NAME
            mv -f "OUTPUT/$ACTIVE_PROJECT.zip" "OUTPUT/$NAME"
    esac
    echo "All done, your ROM should be ready!"
    echo "Thank you for using SimpleKitchen!"
    PRESS_ENTER
    exit 0
}

# Deodexes single file
DEODEX_FILE() {
    local ODEX FILEDIR FILE FILEEXTENSION
    ODEX="$(basename "$1")"
    FILEDIR="$(dirname "$1")"
    FILE="$(echo "$ODEX" | rev | cut -d'.' -f2- | rev)"
    FILEEXTENSION=""
    # Find file that odex relates to
    for EXTENSION in "apk" "jar"; do
        if [[ -f "$FILEDIR/$FILE.$EXTENSION" ]]; then
            FILEEXTENSION="$EXTENSION"
            break
        fi
    done
    if [[ -z "$FILEEXTENSION" ]]; then
        echo "ERROR: Can't determine what $ODEX relates to!"
        return 1
    fi
    FILE="$FILE.$FILEEXTENSION"
    echo "Deodexing $FILE..."
    # If file already contains classes.dex, we should delete proper odex file only
    if [[ "$(unzip -l "$FILEDIR/$FILE" | grep -q "classes.dex"; echo $?)" -eq 0 ]]; then
        echo "INFO: $FILE contains classes.dex already, removing $ODEX"
        rm -f "$FILEDIR/$ODEX"
        return 0
    fi
    rm -rf "$TEMPDIR/$ODEX"
    mkdir -p "$TEMPDIR/$ODEX"
    java -jar -Xmx1024M "$TOOLSDIR/smali/baksmali.jar" -a "$API" -d "$ACTIVE_PROJECT/system/framework" -x "$FILEDIR/$ODEX" -o "$TEMPDIR/$ODEX/DECOMPILED"
    if [[ $? -ne 0 || ! -d "$TEMPDIR/$ODEX/DECOMPILED" ]]; then
        echo "ERROR: Could not deodex $ODEX, aborting!"
        rm -rf "$TEMPDIR/$ODEX"
        PRESS_ENTER
        return 1
    fi
    java -jar -Xmx1024M "$TOOLSDIR/smali/smali.jar" -a "$API" -o "$TEMPDIR/$ODEX/classes.dex" "$TEMPDIR/$ODEX/DECOMPILED"
    if [[ $? -ne 0 || ! -f "$TEMPDIR/$ODEX/classes.dex" ]]; then
        echo "ERROR: Could not re-assemble $ODEX, aborting!"
        rm -rf "$TEMPDIR/$ODEX"
        return 1
    fi
    zip -jrq "$FILEDIR/$FILE" "$TEMPDIR/$ODEX/classes.dex"
    rm -f "$FILEDIR/$ODEX"
    rm -rf "$TEMPDIR/$ODEX"
    return 0
}

# Deodexes everything
DEODEX() (
    API="$(grep "ro.build.version.sdk" "$ACTIVE_PROJECT/system/build.prop" | cut -d'=' -f2)"
    echo "Detected API level $API"
    echo "Usually you don't want to change this value"
    read -rp "Change it? [N/y]: " CHOICE
    case "$CHOICE" in
        y|Y) read -rp "Your selected API level: " API ;;
    esac
    case "$API" in
        [0-9]*) ;;
        *)
            echo "Sorry, it looks like API level is invalid"
            PRESS_ENTER
            return 1
    esac
    find "$ACTIVE_PROJECT" -type f -iname "*.odex" | while read -r ODEX; do
        DEODEX_FILE "$ODEX"
    done
    echo "Deodexing finished"
    PRESS_ENTER
    return 0
)

# Zipaligns single file
ZIPALIGN_FILE() {
    echo "Zipaligning $(basename "$1")..."
    "$ZIPALIGN" -f "$ALIGN" "$1" "$1.zipaligned" >/dev/null 2>&1 && mv -f "$1.zipaligned" "$1"
    return $?
}

# Zipaligns everything
ZIPALIGN() {
    if [[ "$FULLPERFORMANCE" -eq 1 ]]; then
        find "$ACTIVE_PROJECT/system" -type f -iname "*.apk" | (while read -r APK; do
            ZIPALIGN_FILE "$APK" &
        done
        wait)
    else
        find "$ACTIVE_PROJECT/system" -type f -iname "*.apk" | while read -r APK; do
            ZIPALIGN_FILE "$APK"
        done
    fi
    echo
    echo "Zipaligning finished!"
    PRESS_ENTER
}

# Adds or removes ArchiDroid's Init.d
ARCHIDROID_INITD() {
    if [[ ! -f "$ACTIVE_PROJECT/system/bin/debuggerd.real" ]]; then
        mv -f "$ACTIVE_PROJECT/system/bin/debuggerd" "$ACTIVE_PROJECT/system/bin/debuggerd.real"
        cp -R files/archidroid/initd/system/* "$ACTIVE_PROJECT/system/"
        UPDATER_SCRIPT_ADD "files/archidroid/initd/updater-scripts"
    else
        mv -f "$ACTIVE_PROJECT/system/bin/debuggerd.real" "$ACTIVE_PROJECT/system/bin/debuggerd"
        UPDATER_SCRIPT_DEL "files/archidroid/initd/updater-scripts"
    fi
    BUILD_UPDATER_SCRIPT
}

# Adds or removes root
ROOT() {
    if [[ ! -f "$ACTIVE_PROJECT/system/xbin/su" ]]; then
        if [[ -f "$ACTIVE_PROJECT/system/etc/install-recovery.sh" ]]; then
            mv "/system/etc/install-recovery.sh" "/system/etc/install-recovery-2.sh"
        fi
        mkdir -p "$ACTIVE_PROJECT/system/xbin"
        cp -R files/root/system/* "$ACTIVE_PROJECT/system/"
        cp -R "files/root/ARCH/$ARCH/"* "$ACTIVE_PROJECT/"
        cp "$ACTIVE_PROJECT/system/xbin/su" "$ACTIVE_PROJECT/system/xbin/daemonsu"
        mkdir -p "$ACTIVE_PROJECT/system/bin/.ext"
        cp "$ACTIVE_PROJECT/system/xbin/su" "$ACTIVE_PROJECT/system/bin/.ext/.su"
        if [[ -f "$ACTIVE_PROJECT/system/bin/mksh" ]]; then
            cp "$ACTIVE_PROJECT/system/bin/mksh" "$ACTIVE_PROJECT/system/xbin/sugote-mksh"
        else
            cp "$ACTIVE_PROJECT/system/bin/sh" "$ACTIVE_PROJECT/system/xbin/sugote-mksh"
        fi
        cp "$ACTIVE_PROJECT/system/xbin/su" "$ACTIVE_PROJECT/system/xbin/sugote"
        ln -s "/system/xbin/su" "$ACTIVE_PROJECT/system/bin/su"
        ln -s "/system/etc/install-recovery.sh" "$ACTIVE_PROJECT/system/bin/install-recovery.sh"
        UPDATER_SCRIPT_ADD "files/root/updater-scripts"
    else
        if [[ -f "$ACTIVE_PROJECT/system/etc/install-recovery-2.sh" ]]; then
            mv "$ACTIVE_PROJECT/system/etc/install-recovery-2.sh" "$ACTIVE_PROJECT/system/etc/install-recovery.sh"
        else
            rm -f "$ACTIVE_PROJECT/system/etc/install-recovery.sh"
        fi
        rm -f "$ACTIVE_PROJECT/system/bin/su" "$ACTIVE_PROJECT/system/etc/install-recovery.sh" "$ACTIVE_PROJECT/system/app/Superuser.apk" "$ACTIVE_PROJECT/system/xbin/su" "$ACTIVE_PROJECT/system/xbin/daemonsu" "$ACTIVE_PROJECT/system/bin/.ext/.su" "$ACTIVE_PROJECT/system/etc/init.d/99SuperSUDaemon" "$ACTIVE_PROJECT/system/etc/.installed_su_daemon" "$ACTIVE_PROJECT/system/xbin/sugote-mksh" "$ACTIVE_PROJECT/system/xbin/sugote"
        UPDATER_SCRIPT_DEL "files/root/updater-scripts"
    fi
    BUILD_UPDATER_SCRIPT

    echo "Finished rooting!"
    PRESS_ENTER
}

# Debloats or bloats ROM
DEBLOAT() {
    if [[ -d "$ACTIVE_PROJECT/bloatware" ]]; then
        echo "Restoring bloatware..."
        BLACKLIST_CLEAN_RESTORE "bloatware"
        echo "Done, bloatware restored"
    else
        local LINE=""
        while [[ -z "$LINE" ]]; do
            PRINT_BANNER_NEUTRAL
            echo "Before you begin debloating you should specify which cleaning list you want to use"
            echo
            echo "Currently available cleaning lists:"
            PRINT_LINE
            find "files/bloat" -mindepth 1 -maxdepth 1 -type d | sort | while read -r line; do
                basename "$line"
            done
            PRINT_LINE
            echo
            echo "Type any of detected lists above or 'x' to abort"
            read -rp "Your list: " LIST
            PRINT_LINE

            if [[ "$LIST" = "x" ]]; then
                return
            fi
            if [[ ! -d "files/bloat/$LIST" ]]; then
                echo "Wrong selection"
                LINE=""
                PRESS_ENTER
            else
                BLACKLIST_REMOVE "bloat/$LIST"
                BLACKLIST_CLEAN "bloat/$LIST" "bloatware"
                PRESS_ENTER
                return
            fi
        done
    fi
    PRESS_ENTER
}

# Adds or removes busybox
BUSYBOX() {
    if [[ ! -f "$ACTIVE_PROJECT/system/xbin/busybox" ]]; then
        PRINT_BANNER
        echo "Busybox is a core provider for many standard GNU/Linux utilities"
        echo "Here you can specify which Busybox you want to add"
        echo "Stericson's busybox is proven to be stable and work well on stock ROMs with no Busybox"
        echo "On the other hand, CyanogenMod's Busybox is more actively developed"
        echo
        echo "Please note that:"
        echo "* CyanogenMod's Busybox doesn't work on x86 architecture. If you're cooking ROM for such device, stick with stericson's"
        echo "* CyanogenMod's Busybox requires your device to be NEON-capable, typically CortexA9 and newer devices on armv7l"
        echo
        echo "If you don't know what to choose here, I strongly suggest to stick with stericson"
        PRESS_ENTER
        PICK_ONE "files/busybox/busybox"
        if [[ -z "$PICKCHOICE" ]]; then
            return 0
        fi
        cp -R "files/busybox/busybox/$PICKCHOICE/ARCH/$ARCH/"* "$ACTIVE_PROJECT/"
        ln -s "/system/xbin/busybox" "$ACTIVE_PROJECT/system/bin/busybox"
        if [[ -d "files/busybox/busybox/$PICKCHOICE/system" ]]; then
            cp -R "files/busybox/busybox/$PICKCHOICE/system/"* "$ACTIVE_PROJECT/system/"
        fi
        UPDATER_SCRIPT_ADD "files/busybox/updater-scripts"
    else
        rm -f "$ACTIVE_PROJECT/system/bin/busybox" "$ACTIVE_PROJECT/system/xbin/busybox"
        UPDATER_SCRIPT_DEL "files/busybox/updater-scripts"
    fi
    BUILD_UPDATER_SCRIPT
}

# Removes KNOX
REMOVE_KNOX() {
    echo "Removing KNOX..."
    BLACKLIST_REMOVE "knox"
    echo "Done, your ROM should not contain any KNOX apps/folders anymore"
    PRESS_ENTER
}

# Adds or removes insecure ADB
ADB() {
    if [[ -d "$ACTIVE_PROJECT/kernel/boot.img-ramdisk" ]]; then
        if [[ "$(grep -qi "ro.adb.secure=1" "$ACTIVE_PROJECT/kernel/boot.img-ramdisk/default.prop"; echo $?)" -eq 0 ]]; then
            SED_CHANGE_WORD "ro.adb.secure=1" "ro.adb.secure=0" "$ACTIVE_PROJECT/kernel/boot.img-ramdisk/default.prop"
            SED_CHANGE_WORD "ro.secure=1" "ro.secure=0" "$ACTIVE_PROJECT/kernel/boot.img-ramdisk/default.prop"
        else
            SED_CHANGE_WORD "ro.adb.secure=0" "ro.adb.secure=1" "$ACTIVE_PROJECT/kernel/boot.img-ramdisk/default.prop"
            SED_CHANGE_WORD "ro.secure=0" "ro.secure=1" "$ACTIVE_PROJECT/kernel/boot.img-ramdisk/default.prop"
        fi
    fi
}

# Prints banner
PRINT_BANNER() {
    clear
    echo "SimpleKitchen - Version $VERSION"
    echo
    echo "Originally developed by 'JustArchi' - Revived by 'johndah4x0r'"
    echo "Original thread: ${XDALINK}"
    PRINT_LINE
}

PRINT_BANNER_NEUTRAL() {
    clear
    echo "SimpleKitchen - Version $VERSION"
    PRINT_LINE
}
# Prints status of the project
PRINT_PROJECT_STATUS() {
    MESG=""
    ALLFINE=1
    if [[ -d "$ACTIVE_PROJECT/kernel" ]]; then
        ALLFINE=0
        MESG+="Unpacked kernel found!\n"
    fi
    if [[ ! -f "$ACTIVE_PROJECT/boot.img" ]]; then
        ALLFINE=0
        MESG+="No boot.img found, ROM will not boot properly!\n"
    fi
    if [[ ! -d "$ACTIVE_PROJECT/META-INF" ]]; then
        ALLFINE=0
        MESG+="No META-INF folder found, this is not a ROM!\n"
    fi
    if [[ "$ALLFINE" -eq 1 ]]; then
        STAT="OK"
    else
        STAT="WARNING"
    fi
    echo "Project status: $STAT - Choose 'ms' option for more information." >&2
    PRINT_LINE
}

# Prints status of the ROM
PRINT_ROM_STATUS() {
    echo -n "Architecture: ["
    if [[ "$ARCH" = "unknown" && -f "$ACTIVE_PROJECT/system/build.prop" ]]; then
        ARCH="$(grep -i "ro.product.cpu.abi=" "$ACTIVE_PROJECT/system/build.prop" | head -n 1 | cut -d'=' -f2)"
    fi
    echo "$ARCH]"
}

# Print more status
PRINT_MORE_STATUS() {
    PRINT_BANNER_NEUTRAL
    echo "Project status: $STAT"
    echo "Warnings:"
    echo -ne "$MESG"
    PRINT_LINE
    echo "Project name: ${ACTIVE_PROJECT}"
    echo -n "ArchiDroid Init.d: "
    if [[ ! -f "$ACTIVE_PROJECT/system/bin/debuggerd.real" ]]; then
        echo "[NO]"
    else
        echo "[YES]"
    fi
    echo -n "Debloated: "
    if [[ -d "$ACTIVE_PROJECT/bloatware" ]]; then
        echo "[YES]"
    else
        echo "[NO]"
    fi
    echo -n "Deodexed: "
    if [[ -f "$ACTIVE_PROJECT/system/framework/framework.odex" ]]; then
        echo "[NO]"
    else
        echo "[YES]"
    fi
    echo -n "Zipaligned: "
    if [[ -f "$ACTIVE_PROJECT/system/framework/framework-res.apk" && "$("$ZIPALIGN" -c "$ALIGN" "$ACTIVE_PROJECT/system/framework/framework-res.apk"; echo $?)" -eq 0 ]]; then
        echo "[YES]"
    else
        echo "[NO]"
    fi
    echo -n "Rooted: "
    if [[ ! -f "$ACTIVE_PROJECT/system/xbin/su" ]]; then
        echo "[NO]"
    else
        echo "[YES]"
    fi
    echo -n "Busybox: "
    if [[ ! -f "$ACTIVE_PROJECT/system/xbin/busybox" ]]; then
        echo "[NO]"
    else
        echo "[YES]"
    fi
    echo -n "KNOX: "
    if [[ -f "$ACTIVE_PROJECT/system/app/KNOXAgent.apk" ]]; then
        echo "[YES]"
    else
        echo "[NO]"
    fi
    if [[ -d "$ACTIVE_PROJECT/kernel/boot.img-ramdisk" ]]; then
        PRINT_LINE
        echo "KERNEL EXTRACTED"
        echo -n "ADB: "
        if [[ "$(grep -qi "ro.adb.secure=0" "$ACTIVE_PROJECT/kernel/boot.img-ramdisk/default.prop"; echo $?)" -eq 0 ]]; then
            echo "[INSECURE]"
        else
            echo "[SECURE]"
        fi
        echo -n "Kernel Init.d: "
        if [[ "$(grep -qi "sysinit" "$ACTIVE_PROJECT/kernel/boot.img-ramdisk/init.rc"; echo $?)" -eq 0 ]]; then
            echo "[YES]"
        else
            echo "[NO]"
        fi
    fi
    PRINT_LINE
    echo "Originally developed by 'JustArchi' - Forked & revived by 'johndah4x0r'"
    echo "Original thread: ${XDALINK}"
    echo
    read -rp "Press Enter to continue..." junk
    return
}

# Prints available switches
PRINT_SWITCHES() {
    echo "adi   - Enable/Disable ArchiDroid Init.d (software debuggerd hook)"
    echo "bloat - Bloat/Debloat ROM"
    echo "r     - Enable/Disable Root"
    echo "b     - Enable/Disable Busybox"
    echo "d     - Deodex Everything"
    echo "z     - Zipalign Everything"
    echo "knox  - Remove KNOX"
    echo "k     - Kernel/boot.img options"
    PRINT_LINE
    echo "bb    - Build ROM (normal suggested mode)"
    echo "bbe   - Build ROM (expert mode, won't make any checks if your project is OK)"
    echo "ak    - Change AndyH4x0r settings"
    echo "ms    - Show more status information"
    echo "x     - Exit"
    PRINT_LINE
}

# Prints settings of the h4x0r
PAGE_SETTINGS() {
    while :; do
        PRINT_BANNER
        echo -n "Full performance: "
        if [[ "$FULLPERFORMANCE" -eq 1 ]]; then
            echo "[YES]"
        else
            echo "[NO]"
        fi
        PRINT_LINE
        echo "Full performance mode tries to finish common tasks ASAP"
        echo "This includes i.e. calling all job threads at once and waiting for them to"
        echo "finish instead of calling them one-by-one and blocking main thread"
        echo "Due to that, OS may become unresponsive when AndyH4x0r is performing a task"
        echo "Usually it's a good idea to keep it ON, unless you have a very good reason"
        echo "for forcing the kitchen to run in  single-thread mode"
        PRINT_LINE
        echo "p - Full performance switch"
        echo "x - Go back"
        PRINT_LINE
        read -rp "CHOICE: " CHOICE
        case "$CHOICE" in
            p|P)
                if [[ "$FULLPERFORMANCE" -eq 1 ]]; then
                    FULLPERFORMANCE=0
                else
                    FULLPERFORMANCE=1
                fi
                ;;
            x|X) return 0 ;;
        esac
    done
}

# Auto-update feature of AndyH4x0r
CHECK_UPDATE() (
    if [[ -d ".git" && ! -z "$(which git)" ]]; then
        echo "Auto-update in progress..."

        GITVERSION="$(git --version | cut -d' ' -f3)"
        if VERSION_LESS_THAN "$GITVERSION" "$NEEDEDGIT"; then
            echo
            echo "WARNING: Your git version is lower than the required!"
            echo "Your git version: $GITVERSION"
            echo "Required git version: $NEEDEDGIT"
            echo "Auto-update feature has been disabled, please update your git to latest version"
            PRESS_ENTER
            return 0
        fi
        echo "Checking network connection..."
        if [[ "$(wget --spider github.com >/dev/null 2>&1; echo $?)" -ne 0 ]]; then
            echo
            echo "WARNING: Could not connect to github.com, probably your network is down"
            echo "Auto-update feature has been disabled"
            PRESS_ENTER
            return 0
        fi
        REPO="origin"
        OLDHEAD="$(git rev-parse HEAD)"
        CURBRANCH="$(git rev-parse --abbrev-ref HEAD)"
        if [[ "$CURBRANCH" != "$GITHUBBRANCH" ]]; then
            echo "You're currently using $CURBRANCH branch, and this is not the default $GITHUBBRANCH branch. Auto-update feature has been disabled"
            PRESS_ENTER
            return 0
        fi
        if [[ "$(git remote | grep -qi "$REPO"; echo $?)" -ne 0 ]]; then
            git remote add -t "$GITHUBBRANCH" -m "$GITHUBBRANCH" "$REPO" "$GITHUBLINK"
        fi
        echo "Fetching current version..."
        git fetch -q "$REPO" "$GITHUBBRANCH"

        HEAD="$(git rev-parse "$REPO/$GITHUBBRANCH")"
        if [[ ! -z "$HEAD" && "$OLDHEAD" != "$HEAD" ]]; then
            echo "Found new version!"
            echo "Changelog:"
            echo "=========="
            git --no-pager log --abbrev-commit --decorate --date=relative --pretty=format:'%C(bold red)%h%Creset %C(bold green)(%cr)%Creset - %C(bold yellow)%s%Creset %C(bold blue)commited by%Creset %C(bold cyan)%an%Creset' "$OLDHEAD..$HEAD"
            echo # Beacause git log doesn't finish with newline
            echo "=========="
            git pull -q "$REPO" "$GITHUBBRANCH" >/dev/null 2>&1 || (echo; echo "WARNING: AndyH4x0r could not apply update due to conflicts, forced update mode will be used now. Please make proper backups if you need any of your past projects before going to the next step"; PRESS_ENTER; git reset -q --hard; git clean -qfd; git pull -q "$REPO" "$GITHUBBRANCH")
            echo "AndyH4x0r has been updated, it will now restart itself"
            PRESS_ENTER
            exec "$0"
        else
            echo "No new updates found"
            sleep 1
        fi
    fi
)

# Kernel options
KERNEL_OPTS() {
    local OPT
    while :; do
        PRINT_BANNER_NEUTRAL
        echo "Kernel options"
        PRINT_LINE
        if [[ -d "$ACTIVE_PROJECT/kernel/boot.img-ramdisk" ]]; then
            echo "kr    - Repack kernel (apply all ramdisk changes)"
            echo "ka    - Abort repacking (abort all ramdisk changes)"
            echo
            echo "i     - Add Init.d Support (hardware kernel hook)"
            echo "adb   - Enable/Disable insecure ADB"
        elif [[ -f "$ACTIVE_PROJECT/boot.img" ]]; then
            echo "ku    - Unpack kernel (this enables more options!)"
        fi
            echo "x     - Return to main menu"
        read -rp "CHOICE: " OPT
        case $OPT in
            i|I) INITD; break ;;
            adb|ADB) ADB ;;
            ku|KU) KERNEL_EXTRACT ;;
            kr|KR) KERNEL_REPACK ;;
            ka|KA) KERNEL_ABORT ;;
            x|X) break ;;
            *) continue ;;
        esac
    done
}

############################
#   ____ ___  ____  _____  #
#  / ___/ _ \|  _ \| ____| #
# | |  | | | | |_) |  _|   #
# | |__| |_| |  _ <| |___  #
#  \____\___/|_| \_\_____| #
#                          #
############################

# Print help
PRINT_HELP() {
    cat >&2 <<EOF
andyh4x0r - A trusty, and helpful tool to customize & create Android ROMs.

Üsage: andyh4x0r [-h/--help] [-nu/--no-updates/--now]
    -h/--help     -     Show this help screen, then exit.
    -nu/--no-updates/--now  -  Skip auto-updates (to allow faster debugging & testing)

Originally developed by: 'JustArchi'
Current developer: JohnDaH4x0r
Source code (forked) @ https://github.com/johndah4x0r/AndyH4x0r
EOF
}

PRINT_BANNER
echo "Please wait..."

# Cleaning
unset CROSS_COMPILE # We're not cross-compiling anything here and it may cause problems with some makefiles

# Before we begin, make sure that all our tools are available
if [[ "$(which "${TOOLS[@]}" >/dev/null; echo $?)" -ne 0 ]]; then
    MISSINGTOOLS=""
    for TOOL in "${TOOLS[@]}"; do
        if [[ -z "$(which "$TOOL")" ]]; then
            MISSINGTOOLS+=" $TOOL"
        fi
    done
    echo "It looks like you don't have required tool(s):$MISSINGTOOLS"
    echo "This check was made through 'which' command"
    echo "Please install missing tool(s) and launch kitchen again"
    exit 1
fi
echo

# Check LONG_BIT for determining host architecture
HOSTARCH="$(getconf LONG_BIT)"
case "$HOSTARCH" in
    64) HOSTARCH="amd64" ;;
    32) HOSTARCH="i386" ;;
    *) HOSTARCH="amd64" ;; # Unknown, assume amd64
esac

# Set common tools
ZIPALIGN="./$TOOLSDIR/zipalign/$HOSTARCH/zipalign"

# Warn user if not run from root directory
if [ "$PWD" != "$(dirname "$0" | xargs realpath)" ]; then
    echo "WARNING: AndyH4x0r wasn't executed from real parent directory!"
    echo "It might have some consequences!"
    echo
    echo "Changing directory..."
    cd "$(dirname "$0")"
fi

# Check if symlink support is present
if [[ "$(ln -s T1 T2 >/dev/null 2>&1; echo $?)" -ne 0 ]]; then
    echo "ERROR: Current kitchen location doesn't support symbolic links!"
    echo "Symbolic links cannot be used on Windows-based filesystems, such as FAT, NTFS, or VirtualBox shared folder mount on one of the previous"
    echo "You must use AndyH4x0r in native Linux location, such as /root, /home/username, /tmp, or any other mountpoint, which supports symbolic links"
    exit 1
else
    rm -f T2
fi

# Create our temporary directory
mkdir -p "$TEMPDIR"

# Make sure our tools are executable
# This is only required if user downloaded zip and permissions are broken (f.e. due to moving files from windows => linux)
chmod -R 755 tools

# Parse args
for ARG in "$@"; do
    case "$ARG" in
        "-h" | "--help")
            PRINT_HELP
            ;;
        "-nu" | "--no-updates" | "--now")
            AUTOUPDATE="0"; SET_OLDPROJECT
            ;;
        -* | --*)
            PRINT_HELP
            echo "Argument not understood: $ARG" >&2
            exit 1
            ;;
    esac
done

# Check for updates
if [[ "$AUTOUPDATE" -eq 1 ]]; then
    CHECK_UPDATE
fi

while :; do
    PRINT_BANNER_NEUTRAL

    if [[ -z "$ACTIVE_PROJECT" ]]; then
        SET_PROJECT
        continue
    fi

    PRINT_PROJECT_STATUS
    PRINT_ROM_STATUS
    PRINT_SWITCHES
    read -rp "CHOICE: " CHOICE
    case "$CHOICE" in
        ak|AK) PAGE_SETTINGS ;;
        adi|ADI) ARCHIDROID_INITD ;;
        bloat|BLOAT) DEBLOAT ;;
        r|R) ROOT ;;
        b|B) BUSYBOX ;;

        d|D) DEODEX ;;
        z|Z) ZIPALIGN ;;
        knox|KNOX) REMOVE_KNOX ;;
        ms|MS) PRINT_MORE_STATUS ;;
        k|K) KERNEL_OPTS ;;
        bbe|BBE) BUILD "EXPERT" ;;
        bb|BB)
            if [[ "$ALLFINE" -eq 1 ]]; then
                BUILD
            else
                echo "ERROR: Can't build ROM in current status, please read the warnings [ms] and fix them!"
                PRESS_ENTER
            fi
            ;;
        x|X) clear; exit 0;;
    esac
done

exit 0