#!/bin/bash
# meshing-around install helper script

# install.sh
cd "$(dirname "$0")"
program_path=$(pwd)
printf "\n########################"
printf "\nMeshing Around Installer\n"
printf "########################\n"
printf "\nThis script will try and install the Meshing Around Bot and its dependencies.\n"
printf "Installer works best in raspian/debian/ubuntu or foxbuntu embedded systems.\n"
printf "If there is a problem, try running the installer again.\n"
printf "\nChecking for dependencies...\n"

# check if we are in /opt/meshing-around
if [ $program_path != "/opt/meshing-around" ]; then
    printf "\nIt is suggested to project path to /opt/meshing-around\n"
    printf "Do you want to move the project to /opt/meshing-around? (y/n)"
    read move
    if [[ $(echo "$move" | grep -i "^y") ]]; then
        sudo mv $program_path /opt/meshing-around
        cd /opt/meshing-around
        printf "\nProject moved to /opt/meshing-around. re-run the installer\n"
        exit 0
    fi
fi

# check write access to program path
if [[ ! -w ${program_path} ]]; then
    printf "\nInstall path not writable, try running the installer with sudo\n"
    exit 1
fi

# if hostname = femtofox, then we are on embedded
if [[ $(hostname) == "femtofox" ]]; then
    printf "\nDetected femtofox embedded system\n"
    embedded="y"
else
    # check if running on embedded
    printf "\nAre You installing into an embedded system like a luckfox? (y/n)"
    read embedded
fi

if [[ $(echo "${embedded}" | grep -i "^y") ]]; then
    printf "\nDetected embedded skipping dependency installation\n"
else
    # Check and install dependencies
    if ! command -v python3 &> /dev/null
    then
        printf "python3 not found, trying 'apt-get install python3 python3-pip'\n"
        sudo apt-get install python3 python3-pip
    fi
    if ! command -v pip &> /dev/null
    then
        printf "pip not found, trying 'apt-get install python3-pip'\n"
        sudo apt-get install python3-pip
    fi

    # double check for python3 and pip
    if ! command -v python3 &> /dev/null
    then
        printf "python3 not found, please install python3 with your OS\n"
        exit 1
    fi
    if ! command -v pip &> /dev/null
    then
        printf "pip not found, please install pip with your OS\n"
        exit 1
    fi
    printf "\nDependencies installed\n"
fi

# add user to groups for serial access
printf "\nAdding user to dialout, bluetooth, and tty groups for serial access\n"
sudo usermod -a -G dialout $USER
sudo usermod -a -G tty $USER
sudo usermod -a -G bluetooth $USER

# copy service files
cp etc/pong_bot.tmp etc/pong_bot.service
cp etc/mesh_bot.tmp etc/mesh_bot.service
cp etc/mesh_bot_reporting.tmp etc/mesh_bot_reporting.service

# generate config file, check if it exists
if [[ -f config.ini ]]; then
    printf "\nConfig file already exists, moving to backup config.old\n"
    mv config.ini config.old
fi

cp config.template config.ini
printf "\nConfig files generated!\n"

# update lat,long in config.ini 
latlong=$(curl --silent --max-time 20 https://ipinfo.io/loc || echo "48.50,-123.0")
IFS=',' read -r lat lon <<< "$latlong"
sed -i "s|lat = 48.50|lat = $lat|g" config.ini
sed -i "s|lon = -123.0|lon = $lon|g" config.ini
echo "lat,long updated in config.ini to $latlong"

# check if running on embedded
if [[ $(echo "${embedded}" | grep -i "^y") ]]; then
    printf "\nDetected embedded skipping venv\n"
else
    printf "\nRecomended install is in a python virtual environment, do you want to use venv? (y/n)"
    read venv

    if [[ $(echo "${venv}" | grep -i "^y") ]]; then
        # set virtual environment
        if ! python3 -m venv --help &> /dev/null; then
            printf "Python3/venv error, please install python3-venv with your OS\n"
            exit 1
        else
            echo "The Following could be messy, or take some time on slower devices."
            echo "Creating virtual environment..."
            #check if python3 has venv module
            if [[ -f venv/bin/activate ]]; then
                printf "\nFound virtual environment for python\n"
                python3 -m venv venv
                source venv/bin/activate
            else
                printf "\nVirtual environment not found, trying `sudo apt-get install python3-venv`\n"
                sudo apt-get install python3-venv
            fi
            # create virtual environment
            python3 -m venv venv

            # double check for python3-venv
            if [[ -f venv/bin/activate ]]; then
                printf "\nFound virtual environment for python\n"
                source venv/bin/activate
            else
                printf "\nPython3 venv module not found, please install python3-venv with your OS\n"
                exit 1
            fi

            printf "\nVirtual environment created\n"

            # config service files for virtual environment
            replace="s|python3 mesh_bot.py|/usr/bin/bash launch.sh mesh|g"
            sed -i "$replace" etc/mesh_bot.service
            replace="s|python3 pong_bot.py|/usr/bin/bash launch.sh pong|g"
            sed -i "$replace" etc/pong_bot.service

            # install dependencies to venv
            pip install -U -r requirements.txt
        fi
    else
        printf "\nSkipping virtual environment...\n"
        # install dependencies to system
        printf "Are you on Raspberry Pi(debian/ubuntu)?\nshould we add --break-system-packages to the pip install command? (y/n)"
        read rpi
        if [[ $(echo "${rpi}" | grep -i "^y") ]]; then
            pip install -U -r requirements.txt --break-system-packages
        else
            pip install -U -r requirements.txt
        fi
    fi
fi

printf "\n\n"
echo "Which bot do you want to install as a service? Pong Mesh or None? (pong/mesh/n)"
echo "Pong bot is a simple bot for network testing, Mesh bot is a more complex bot more suited for meshing around"
read bot

# set the correct path in the service file
replace="s|/dir/|$program_path/|g"
sed -i $replace etc/pong_bot.service
sed -i $replace etc/mesh_bot.service
sed -i $replace etc/mesh_bot_reporting.service
# set the correct user in the service file?

#ask if we should add a user for the bot
if [[ $(echo "${embedded}" | grep -i "^n") ]]; then
    printf "\nDo you want to add a local user (meshbot) no login, for the bot? (y/n)"
    read meshbotservice
fi

if [[ $(echo "${meshbotservice}" | grep -i "^y") ]] || [[ $(echo "${embedded}" | grep -i "^y") ]]; then
    sudo useradd -M meshbot
    sudo usermod -L meshbot
    whoami="meshbot"
    echo "Added user meshbot with no home directory"
    sudo usermod -a -G dialout $whoami
    sudo usermod -a -G tty $whoami
    sudo usermod -a -G bluetooth $whoami
    echo "Added meshbot to dialout, tty, and bluetooth groups"

    sudo chown -R $whoami:$whoami $program_path/logs
    sudo chown -R $whoami:$whoami $program_path/data
    echo "Permissions set for meshbot on logs and data directories"
else
    whoami=$(whoami)
fi
# set the correct user in the service file
replace="s|User=pi|User=$whoami|g"
sed -i $replace etc/pong_bot.service
sed -i $replace etc/mesh_bot.service
sed -i $replace etc/mesh_bot_reporting.service
replace="s|Group=pi|Group=$whoami|g"
sed -i $replace etc/pong_bot.service
sed -i $replace etc/mesh_bot.service
sed -i $replace etc/mesh_bot_reporting.service
printf "\n service files updated\n"

if [[ $(echo "${bot}" | grep -i "^p") ]]; then
    # install service for pong bot
    sudo cp etc/pong_bot.service /etc/systemd/system/
    sudo systemctl enable pong_bot.service
    sudo systemctl daemon-reload
    echo "to start pong bot service: systemctl start pong_bot"
    service="pong_bot"
fi

if [[ $(echo "${bot}" | grep -i "^m") ]]; then
    # install service for mesh bot
    sudo cp etc/mesh_bot.service /etc/systemd/system/
    sudo systemctl enable mesh_bot.service
    sudo systemctl daemon-reload
    echo "to start mesh bot service: systemctl start mesh_bot"
    service="mesh_bot"
fi

# check if running on embedded for final steps
if [[ $(echo "${embedded}" | grep -i "^n") ]]; then
    # ask if emoji font should be installed for linux
    printf "\nDo you want to install the emoji font for debian/ubuntu linux? (y/n)"
    read emoji
    if [[ $(echo "${emoji}" | grep -i "^y") ]]; then
        sudo apt-get install -y fonts-noto-color-emoji
        echo "Emoji font installed!, reboot to load the font"
    fi

    printf "\nOptionally if you want to install the multi gig LLM Ollama compnents we will execute the following commands\n"
    printf "\ncurl -fsSL https://ollama.com/install.sh | sh\n"
    printf "ollama pull gemma2:2b\n"
    printf "Total download is multi GB, recomend pi5/8GB or better for this\n"
    # ask if the user wants to install the LLM Ollama components
    printf "\nDo you want to install the LLM Ollama components? (y/n)"
    read ollama
    if [[ $(echo "${ollama}" | grep -i "^y") ]]; then
        curl -fsSL https://ollama.com/install.sh | sh

        # ask if want to install gemma2:2b
        printf "\n Ollama install done now we can install the Gemma2:2b components\n"
        echo "Do you want to install the Gemma2:2b components? (y/n)"
        read gemma
        if [[ $(echo "${gemma}" | grep -i "^y") ]]; then
            ollama pull gemma2:2b
        fi
    fi

    if [[ $(echo "${meshbotservice}" | grep -i "^y") ]]; then
        # document the service install
        printf "To install the %s service and keep notes, copy and paste the following commands:\n\n" "$service"
        printf "sudo cp %s/etc/%s.service /etc/systemd/system/etc/%s.service\n" "$program_path" "$service" "$service"
        printf "sudo systemctl daemon-reload\n"
        printf "sudo systemctl enable %s.service\n" "$service"
        printf "sudo systemctl start %s.service\n" "$service"
        printf "sudo systemctl status %s.service\n\n" "$service"
        printf "To see logs and stop the service:\n"
        printf "sudo journalctl -u %s.service\n" "$service"
        printf "sudo systemctl stop %s.service\n" "$service"
        printf "sudo systemctl disable %s.service\n" "$service"
    fi
    
    if [[ $(echo "${venv}" | grep -i "^y") ]]; then
        printf "\nFor running on venv, virtual launch bot with './launch.sh mesh' in path $program_path\n"
    fi

    printf "\nGood time to reboot? (y/n)"
    read reboot
    if [[ $(echo "${reboot}" | grep -i "^y") ]]; then
        sudo reboot
    fi
else
    # we are on embedded
    # replace "type = serial" with "type = tcp" in config.ini
    replace="s|type = serial|type = tcp|g"
    sed -i "$replace" config.ini
    # replace "# hostname = meshtastic.local" with "hostname = localhost" in config.ini
    replace="s|# hostname = meshtastic.local|hostname = localhost|g"
    sed -i "$replace" config.ini
    printf "\nConfig file updated for embedded\n"

    # Set up the meshing around service
    sudo cp /opt/meshing-around/etc/$service.service /etc/systemd/system/$service.service
    sudo systemctl daemon-reload
    sudo systemctl enable $service.service
    sudo systemctl start $service.service

    printf "sudo systemctl status %s.service\n\n" "$service"
    printf "To see logs and stop the service:\n"
    printf "sudo journalctl -u %s.service\n" "$service"
    printf "sudo systemctl stop %s.service\n" "$service"
    printf "sudo systemctl disable %s.service\n" "$service"
    read -p "Press enter to complete the installation"
fi

printf "\nInstallation complete!\n"

exit 0
# after install shenannigans
# add 'bee = True' to config.ini General section. You will likley want to clean the txt up a bit
# wget https://courses.cs.washington.edu/courses/cse163/20wi/files/lectures/L04/bee-movie.txt -O bee.txt