#!/home/autismbot1/ze_runner/venv/bin/python3
import os
import sys
import subprocess
import atexit
import pwd
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import random
import signal
import socket
import codecs
import json
import datetime
import time
import glob

restart_time = datetime.datetime.now() + datetime.timedelta(hours=3)
the_undesired_crash_counter = 0 #hate this monkey solution

whoami = subprocess.getoutput("whoami")
with open(f'/home/{whoami}/ze_runner/config.json') as jsonfile:
    data_ports = json.load(jsonfile)
looptestPath = f"/home/{whoami}/.steam/debian-installation/steamapps/common/Counter-Strike Source/cstrike/cfg/looptest.cfg"
chatmsg = ""

def overwrite_file_access():
    #setting defaults with setfacl for the download directory does not work seemingly
    subprocess.Popen(["chmod", "-R", "g+rwx", f"/home/{whoami}/.steam/debian-installation/steamapps/common/Counter-Strike Source/cstrike/download"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).communicate()

def writeCfgInput(Input_user):
    with open(looptestPath, 'w') as f:
        f.write(Input_user)
    #print("wrote to file: ", Input_user)
    if "connect" in Input_user or "retry;" in Input_user:
        #give extra time for disconnect, retry and connect commands
        time.sleep(1.0)
    else:
        time.sleep(0.35)
    open(looptestPath, 'w').close() #clearing file.

def clean_up_files():
    #deleting POSIX shared memory objects, as long as one process has them open they exist. THis is to prevent /dev/shm from being full
    #due to steam child processes.
    #even with steam turned offline might there be chromium web browsers left over from steam who still hold processes open.
    #only kind of potential issues from this is steam cloud being out of sync, which is really fucking irrelevant.
    for pattern in ["/tmp/steam*", "/tmp/dbus*", "/tmp/pressure*", "/tmp/tigervnc*", "/tmp/dumps*", "/dev/shm/u100*"]:
        for path in glob.glob(pattern):
            subprocess.run(["rm", "-rf", path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)

    #clean up the game cache as it otherwise just keeps growing in gigabyte size
    subprocess.run(["rm", "-rf", f"/home/{whoami}/.steam/steam/steamapps/common/Counter-Strike Source/cstrike/cache"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)

def check_if_bz2_downloading():
    #users should only have permissions to delete their own files probably
    #check if any bz2 files left over.
    for f in glob.glob(f"/home/{whoami}/.steam/steam/steamapps/common/Counter-Strike Source/cstrike/download/**/*.bz2", recursive=True):
        file_size = None
        while True:
            time.sleep(10)
            if not os.path.exists(f):
                break  # finished downloading, bz2 file is removed.
            cur_file_size = os.path.getsize(f)
            if file_size == cur_file_size:
                # delete the bz2 file if its not progressing downloading
                subprocess.run(["rm", "-rf", f], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                break
            file_size = cur_file_size

def delete_bsp_files():
    #quite a more radical approach to just always delete all maps, well the download should be quick and the remaining bots have the bsp in memory...
    #the bots would have struggle connecting sometimes due to bsp files that were already downloaded before hand (maybe corrupted?)
    for f in glob.glob(f"/home/{whoami}/.steam/debian-installation/steamapps/common/Counter-Strike Source/cstrike/download/maps/*"):
        #ai slop IF statement for checking if file modified less than 10 minutes ago.
        if time.time() - os.path.getmtime(f) < 600:
            continue
        subprocess.run(["rm", "-rf", f], stdout=subprocess.PIPE)

def exit_handler():
    print('reached exithandler')
    #securing the looptest.cfg wont be stuck accidently with commands
    kill_owned_process("pidof cstrike_linux64")
    kill_owned_process("pidof xterm")

    clean_up_files()
    check_if_bz2_downloading()
    delete_bsp_files()

    subprocess.getoutput(f"pkill -9 -u {whoami}")

def kill_user_owned_pid(pid):
    #print('pid: ', pid, ' killed')
    pid = int(pid.strip())
    os.kill(pid, signal.SIGKILL)
    time.sleep(10)

def return_user_owned_pid(pidof):
    owner_pid = subprocess.getoutput([f"{pidof}"])
    if owner_pid:
        for pid in owner_pid.split(" "):
            username = subprocess.getoutput([f"""ps -o user= -p {pid}"""])
            if username == whoami:
                return pid
    return None

def kill_owned_process(pidof):
    pid = return_user_owned_pid(pidof)
    while pid:
        kill_user_owned_pid(pid)
        pid = return_user_owned_pid(pidof)

def restart_sdl_and_steam():
    #subprocess.getoutput(["screen -XS XTERM quit"])
    kill_owned_process("pidof cstrike_linux64")
    kill_owned_process("pidof xterm")

    subprocess.getoutput([f'vncserver -kill']) #only displays vncservers for the specific user.
    subprocess.getoutput([f'vncserver -list -cleanstale']) #cleans stale sessions by removing files from disk
    time.sleep(5)

    cmd = f'vncserver -localhost no -geometry 1x1 -depth 24'
    #cmd = f'vncserver -localhost no -geometry 800x800 -depth 24'
    #print(f'cmd: {cmd}')
    subprocess.getoutput(cmd)
    print('reached .bashrc executing steam and variables')

def bot_connect(data):
    #use whatever ip you want here to connect with
    str1 = ""
    if "connect to ze" == data:
        str1 = f"connect {data_ports['server_ip_port_ze']};"
    elif "connect to ze2" == data:
        str1 = f"connect {data_ports['server_ip_port_ze2']};" #wait 15000;
    writeCfgInput(str1)

def cpulimit_pid_of_game():
    # ' > /dev/null' redirects stdout to /dev/null
    # '2>&1' redirects stderr to the same place as stdout
    pid = return_user_owned_pid("pidof cstrike_linux64")
    if pid is None:
        return
    cmd = f"cpulimit --pid={pid} --limit=25 --background > /dev/null 2>&1"
    #cmd = f"cpulimit --pid={pid} --limit=55 --background > /dev/null 2>&1"
    subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).communicate()[0]

    time.sleep(3)
    for source_engine_lock in glob.glob("/tmp/source_engine_*"):
        subprocess.run(["rm", "-rf", source_engine_lock], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    overwrite_file_access()

if __name__ == '__main__':
    atexit.register(exit_handler)
    local_port = data_ports['udp_port']
    external_port_messages = data_ports['chat_external_port']
    buffer_size = 4096 #potentially not large enough?

    clean_up_files()
    check_if_bz2_downloading()
    delete_bsp_files()

    restart_sdl_and_steam()
    is_bot_connected_to_ze2 = False

    print('preparing to launch game....')
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.bind(("", local_port))
    sock.settimeout(5.0)
    messager_name = ""

    #give the game some time to launch
    fail_safe = 5
    while return_user_owned_pid("pidof cstrike_linux64") is None:
        #just a fail safe to prevent being stuck forever.
        if fail_safe <= 0:
            sys.exit(1)
        time.sleep(10)
        print("launching game...")
        fail_safe -= 1
    time.sleep(10)
    cpulimit_pid_of_game()

    try:
        while True:
            try:
                #print("socket waiting for recvfrom")
                data, addr = sock.recvfrom(buffer_size)
            except socket.timeout:
                continue
            data = codecs.decode(data, "utf-8", "ignore")
            ip = addr[0]
            port = addr[1]
            #print('port: ', port, " ip: ", ip)
            #print('data: ', data)
            if not data:
                continue

            #print("ip: ", ip, " port: ", port)
            if ip == data_ports['discord_bot_ip'] and port == external_port_messages:
                if messager_name in data:
                    messager_name = ""
                response_msg = f"""say {messager_name} {data}"""
                print("remote UDP packet response_msg: ", response_msg)
                writeCfgInput(response_msg)
            if ip != data_ports['ovh_ip']:
                continue
            elif data == "bot kicked server full":
                print('bot kicked server full: ', datetime.datetime.now().time())
            elif "autismo connected to ze" == data:
                print('Bot connected to ze!')
                is_bot_connected_to_ze2 = False
                the_undesired_crash_counter = 0
            elif "not connected to ze2" == data:
                is_bot_connected_to_ze2 = False
            elif "autismo connected to ze2" == data:
                print('Bot connected to ze2!')
                the_undesired_crash_counter = 0
                is_bot_connected_to_ze2 = True
            elif "connect to ze" == data or ("connect to ze2" == data and not is_bot_connected_to_ze2):
                if datetime.datetime.now() >= restart_time or return_user_owned_pid("pidof cstrike_linux64") is None or the_undesired_crash_counter >= 5:
                    #it already finished downloading the contnet, it just cant connect. probably stuck. shitty solution welp
                    kill_owned_process("pidof cstrike_linux64")
                    sock.close()
                    print('exiting after running the game for several hours or game being stuck on map change.')
                    sys.exit(1)
                print('data: ', data, ' the_undesired_crash_counter: ', the_undesired_crash_counter)
                the_undesired_crash_counter += 1
                check_if_bz2_downloading()
                overwrite_file_access()
                bot_connect(data)
            elif "clientmessage:" in data:
                messager_name = data.split("clientmessage:", 1)[1].split(f" {data_ports['magic_secret']}")[0]
                databyte_send_message = messager_name + data.split(f"{data_ports['magic_secret']}")[1]
                sock.sendto(databyte_send_message.encode(), (data_ports["discord_bot_ip"], external_port_messages))
                #print('databyte_send_message: ', databyte_send_message)
    finally:
        sock.close()
