#!/bin/bash
#
# Date: 12/2024
# Author: Industrial Shields®
# Hardware: UPSafePI and SARA R412M
# Description:
# This script prompts the user for the ISP's APN, username, password, and the desired RAT as parameters.
# It then configures the modem by passing AT commands and connects to the network using CHAP authentication.
# Finally, it creates a service named pppd so that the desired RAT (LTE Cat M1, NB-IoT, or GPRS/eGPRS)
# is automatically configured with a network interface called ppp0 every time the Raspberry PI is started.

set -euo pipefail

PHONE="*99***1#"

LTE="LTE Cat M1 or Long Term Evolution (4G) category M1"
NB="Narrow Band IoT (NB-IoT)"
GPRS="GPRS/eGPRS"

echo "Please enter your APN"
read APN
echo -e "\r\nPlease enter your ISP username"
read USERNAME
echo -e "\r\nPlease enter your ISP password"
read PASSWORD
echo -e "\r\nPlease select the desired Radio Access Technology (1, 2 or 3):"
echo "--> 1: ${LTE}"
echo "--> 2: ${NB}"
echo "--> 3: ${GPRS}"
read VALUE

if [[ $VALUE =~ ^[1-3]$ ]]; then
    case $VALUE in
        1)
            RAT="lte-m"
            ;;
        2)
            RAT="nb-iot"
            ;;
        3)
            RAT="gprs"
            ;;
    esac
else
    echo "Invalid value. Please enter a value between 1 and 3."
    exit 1
fi

SERVICE="pppd"

######################################################################
cat > /lib/systemd/system/${SERVICE}.service <<EOF
[Unit]
Description=SARA-R412M setup

[Service]
Type=simple
ExecStart=/usr/bin/python3 /usr/local/bin/network-setup.py ${RAT}
ExecStop=/usr/bin/python3 /usr/local/bin/network-setup.py clear
Restart=on-failure
RemainAfterExit=true
KillSignal=SIGKILL

[Install]
WantedBy=multi-user.target
EOF

######################################################################
if ! grep -q '^DefaultTimeoutStopSec=5s$' /etc/systemd/system.conf; then
    echo "DefaultTimeoutStopSec=5s" >> /etc/systemd/system.conf
fi

######################################################################
cat > /etc/ppp/options <<EOF
EOF

######################################################################
cat > /etc/ppp/chap-secrets <<EOF
'${USERNAME}' * '${PASSWORD}' *
EOF


######################################################################
cat > /usr/local/bin/network-setup.py <<EOF
import subprocess
import time
import serial
import os
import sys
import threading
import datetime

filename = os.path.basename(__file__)
usage = f"Usage: 'python {filename} gprs / nb-iot / lte-m / clear'"

# Manage arguments
if len(sys.argv) != 2:
	print(usage)
	sys.exit(1)
else:
	# Get argument
	arg = sys.argv[1]

# ISP settings
ISP = {
    'username': '${USERNAME}',
    'password': '${PASSWORD}',
    'phone_number': '${PHONE}',
    'apn': '${APN}',
}

# Serial port settings
serial_port = '/dev/ttyAMA3'

# AT commands to set GPRS configuration
gprs_cmds = [
	'+++',
	'Z',
	'',
	'+CFUN=0',
	'+CPSMS=0',
	'+UPSMR=0',
	'+UMNOPROF=100',
	'+CPWROFF',
	'+URAT=9',
	'+CPWROFF',
	'+CGDCONT=1,"IP","{}","0.0.0.0",0,0'.format(ISP['apn']),
	'+UAUTHREQ=1,2,"{}","{}"'.format(ISP['username'], ISP['password']),
	'+CFUN=1',
	'+CFUN=15',
	'+CGREG?',
	'+CSQ',
	'D{}'.format(ISP['phone_number']),
]

# AT commands for NB-IoT
nb_iot_cmds = [
	'+++',
	'Z',
	'',
	'+CFUN=0',
	'+CPSMS=0',
	'+UPSMR=0',
	'+UMNOPROF=100',
	'+CPWROFF',
	'+URAT=8',
	'+CPWROFF',
	'+UBANDMASK=1,524420',
	'+CGDCONT=1,"IP","{}","0.0.0.0",0,0'.format(ISP['apn']),
	'+UAUTHREQ=1,2,"{}","{}"'.format(ISP['username'], ISP['password']),
	'+CFUN=1',
	'+CFUN=15',
#	'+UMNOPROF?',
#	'+URAT?',
#	'+UBANDMASK?',
#	'+CGDCONT?',
#	'+COPS?',
	'+CEREG?',
	'+CSQ',
	'D{}'.format(ISP['phone_number']),
]

# AT commands for LTE-Cat-M1 (also LTE-M)
lte_m_cmds = [
	'+++',
	'Z',
	'',
	'+CFUN=0',
	'+CPSMS=0',
	'+UPSMR=0',
	'+UMNOPROF=100',
	'+CPWROFF',
	'+URAT=7',
	'+CPWROFF',
	'+UBANDMASK=0,524420',
	'+CGDCONT=1,"IP","{}","0.0.0.0",0,0'.format(ISP['apn']),
	'+UAUTHREQ=1,2,"{}","{}"'.format(ISP['username'], ISP['password']),
	'+CFUN=1',
	'+CFUN=15',
#	'+UMNOPROF?',
#	'+URAT?',
#	'+UBANDMASK?',
	'+CEREG?',
	'+CSQ',
	'D{}'.format(ISP['phone_number']),
]

# Baud rates to try
baud_rates = [38400, 115200, 57600, 9600, 14400, 19200, 28800]

baud_rate = 115200

# PPP commands for setting the ppp0 interface
pppd_cmd = "sudo pppd debug updetach maxfail 0 dump noauth user {} password {} {} {} local asyncmap 0 default-mru mtu 1500 lcp-echo-failure 3 lcp-echo-interval 10 ipcp-accept-local ipcp-accept-remote noipdefault ipcp-restart 10 ipcp-max-configure 30 ipcp-max-failure 10 defaultroute replacedefaultroute noipv6 usepeerdns ".format(ISP['username'], ISP['password'], serial_port, baud_rate)
PPP_COMMANDS = [pppd_cmd]

######################################################################
def configure_modem(commands, ser):
    cmd_fails = 0
    if ser is None:
        print(f'Serial port {serial_port} could not open')
        sys.exit(1)

    for command in commands:
        time.sleep(0.2)
        rx = send_at(ser, command)
        if rx is None:
            cmd_fails += 1
            manage_fails(ser, cmd_fails)

        if command in ['+CFUN=15', '+CPWROFF']:
            print(f'Waiting 5 seconds...')
            time.sleep(5)
            print('OK')
            send_at_until_ok(ser)

        if command in ['+CGREG?', '+CEREG?', '+CSQ']:
            registered = wait_for_registration(ser, command)
            if not registered:
                break

    if registered:
        time.sleep(1)
        for command in PPP_COMMANDS:
            subprocess.run(command.split())

######################################################################
def get_digit(rx):
    csq_value = rx.split(":")[1].strip().replace(",", ".")
    csq_num = ''
    for char in csq_value:
        if char == '.' or char.isdigit():
            csq_num += char
        elif csq_num and not char.isdigit():
            break

    if csq_num:
        csq_float = float(csq_num)
        return csq_float

######################################################################
def wait_for_registration(ser, command):
    if command == '+CGREG?':
        expected_response = '+CGREG: 0,5'
    elif command == '+CEREG?':
        expected_response = '+CEREG: 0,5'
    elif command == '+CSQ':
        expected_response = "+CSQ: 14,99"

    min_value = 8.99
    timeout = 360
    start_time = time.time()
    while (time.time() - start_time) < timeout:
        rx = send_at(ser, command)
        if expected_response in rx:
            return True
        elif command != '+CGREG?' and command != '+CEREG?' and '+CSQ:' in rx:
            csq_value = get_digit(rx)
            if csq_value >= min_value and csq_value != 99.99:
                return True
        time.sleep(0.2)
    return False

######################################################################
def open_port(baud_rate):
    print(f'opening serial port {serial_port} with baud rate {baud_rate} ...')
    port = serial.Serial(serial_port, baud_rate, timeout=1)
    print('ok')
    port.flushInput()
    time.sleep(1)
    print('ok')
    return port

######################################################################
def write_cmd(ser, cmd):
    if cmd != '+++':
        cmd = f'AT{cmd}\r\n'

    print(f">> Sending {cmd}")
    ser.write(cmd.encode('utf-8'))


######################################################################
def read_response(ser, timeout=0.2):
    start_time = time.time()
    rx = b''
    count = 0
    while (time.time() - start_time) < timeout:
        rx_bytes = ser.inWaiting()
        if rx_bytes:
            rx += ser.read(rx_bytes)
            if rx.endswith(b'OK\r\n') or rx.endswith(b'150000000\r\n'):
                return rx.decode('utf-8', errors='ignore')
    return None

######################################################################
def manage_fails(ser, cmd_fails):
    print(f"{cmd_fails} commands failed")
    if cmd_fails >= 4:
        close_port(ser)
        main()
        sys.exit(0)

######################################################################
def send_at_until_ok(ser):
    while True:
        write_cmd(ser, '')
        time.sleep(0.1)
        response = read_response(ser, 1)
        if response is not None and 'OK' in response:
            ser.flush()
            print("Ready")
            break

######################################################################
def send_at(ser, cmd, tries=5, timeout=1):
    write_cmd(ser, cmd)
    for i in range(tries):
        response = read_response(ser, timeout)
        print(f'{response}')
        if response is not None:
            return response
    print(f"No response for {cmd} command")
    return None

######################################################################
def clear_pppd():
    try:
        output = subprocess.check_output(['pgrep', 'pppd'], stderr=subprocess.STDOUT)
        if output:
            subprocess.call(['sudo', 'killall', 'pppd'])
            subprocess.call(['sudo', 'poff', '-a'])

        output = subprocess.check_output(['ifconfig', 'ppp0'], stderr=subprocess.STDOUT)
        if b'ppp0:' in output:
            subprocess.call(['sudo', 'ifconfig', 'ppp0', 'down'])
            subprocess.call(['sudo', 'killall', 'pppd'])
            subprocess.call(['sudo', 'poff', '-a'])

    except subprocess.CalledProcessError as e:
        output = e.output
        pass

######################################################################
def trigger_reset():
    print('triggering reset...')
    subprocess.call(['pinctrl', 'set', '26', 'op', 'dh'])
    time.sleep(11)
    subprocess.call(['pinctrl', 'set', '26', 'op', 'dl'])
    time.sleep(2)
    print("OK trigger reset")

######################################################################
def close_port(ser):
    if ser.isOpen():
        print("closing port...")
        ser.flushInput()
        ser.flushOutput()
        ser.close()

######################################################################
def main():
    timeSpent = time.time()
    now = datetime.datetime.now()
    print(now)
    try:
        ser = None
        clear_pppd()
        trigger_reset()

        for baud_rate in baud_rates:
            ser = open_port(baud_rate)
            if ser.isOpen():
                print(f'Serial port {serial_port} opened with baud rate {baud_rate}')
                response = send_at(ser, '', tries=3)  # Send AT command to check if modem responds
                if response and 'OK' in response:
                    rx = send_at(ser, '+IPR=115200', tries=1)  # Send AT command to check if modem responds
                    break  # Break the loop if modem responds
                else:
                    ser.close()

        if baud_rate:
            ser = open_port(115200)  # Open port at baud rate 115200
            if ser.isOpen():
                print(f'Serial port {serial_port} opened with baud rate 115200')
                configure_modem(gprs_cmds, ser)
            else:
                print('Failed to open serial port with baud rate 115200')
        else:
            print(f'Unable to open serial port {serial_port} with any baud rate')

    except Exception as e:
        print("Exception: ", e)

    finally:
        close_port(ser)
        timeSpent = time.time() - timeSpent
        print("-------- TIME SPENT ", timeSpent)

######################################################################
# Start
if __name__ == "__main__":
    if arg == 'clear':
        print("Clearing configurations...")
        sys.exit(0)

    if arg not in ['gprs', 'nb-iot', 'lte-m']:
        print(usage)
        sys.exit(1)

    modem_commands = {
        'gprs': gprs_cmds,
        'nb-iot': nb_iot_cmds,
        'lte-m': lte_m_cmds
    }

    ser = open_port(baud_rate)
    commands = modem_commands[arg]
    configure_modem(commands, ser)
    ser.close()
EOF


######################################################################
chmod 755 /usr/local/bin/network-setup.py
systemctl enable ${SERVICE}
if systemctl is-active ${SERVICE} >/dev/null 2>&1; then
    systemctl restart ${SERVICE}
else
    systemctl start ${SERVICE}
fi
systemctl daemon-reload

######################################################################
sync
exit 0