bot6/stuff.py

import irctokens
from config import config as Config
from util import Util
from commands import Command
from youtube import YouTube
import sys, importlib, time


def stuff(bot, sock):
    config = Config
    util = Util(config, sock)
    command = Command(config)
    server = bot.server
    send = util.send

    def mesg(msg: str, t=None):
        util.mesg(msg, t)

    #    mesg=util.mesg
    server_caps = []
    wanted_caps = config.capabilities
    chan = config.server.channel  # main channel
    autojoin_done = False
    is_ctcp = False
    is_pm = False
    mode = "init"
    nick_override = False

    def auth(
        nick=config.self.nick,
        passwd=config.server.nickserv_pass,
        auth="nickserv",
        nickserv_auth=config.server.nickserv_auth,
    ):
        # TODO: handle auth that isn't nickserv
        if auth.lower() == "nickserv":  # line.source.split("!")[0]
            # TODO: on most network can probably do "PRIVMSG NickServ@services. :help"
            # TODO: support actually checking the nickserv mask properly
            if nickserv_auth:
                nick_override = True
                if config.server.nickserv_squery:
                    util.send(
                        irctokens.build(
                            "SQUERY", ["NickServ", f"IDENTIFY {nick} {passwd}"]
                        ).format()
                    )
                    util.send(
                        irctokens.build(
                            "SQUERY",
                            ["NickServ", f"{config.server.nickserv_recover} {nick}"],
                        ).format()
                    )
                else:
                    util.mesg(f"IDENTIFY {nick} {passwd}", config.server.nickserv_path)
                    util.mesg(
                        f"{config.server.nickserv_recover} {nick}",
                        config.server.nickserv_path,
                    )
        # attempt to re-nick just in case
        send(irctokens.build("NICK", [config.self.nick]).format())

    def configure():
        config = importlib.reload(sys.modules["config"]).config
        util = Util(config, sock)
        command = importlib.reload(sys.modules["commands"]).Command(config)
        command.YouTube = importlib.reload(sys.modules["youtube"]).YouTube
        command.util = util
        command.YouTube.util = util
        prefixes = config.cmd.prefixes
        admin_accounts = config.admin.accounts
        admin_users = config.admin.hostmasks
        admin_only = config.cmd.admin_only
        return (
            command,
            command.util,
            config,
            util,
            prefixes,
            admin_accounts,
            admin_users,
            admin_only,
        )

    (
        command,
        command.util,
        config,
        util,
        prefixes,
        admin_accounts,
        admin_users,
        admin_only,
    ) = configure()
    send = util.send

    send(irctokens.build("NICK", [config.self.nick]).format())
    send(
        irctokens.build(
            "USER", [config.self.username, "0", "*", config.self.realname]
        ).format()
    )
    while True:
        self_nick = server.nickname
        recv_data = sock.recv(1024)
        recv_lines = server.recv(recv_data)

        for line in recv_lines:
            try:
                server.parse_tokens(line)
            except IndexError:
                print("\x1b[31;1mNGIRCD SUCKS\x1b[0m ", line)
                continue
            stri = line.format()
            for k, v in util.dict.items():
                stri = stri.replace(k, v)
            print(f"{time.strftime('%H:%M:%S')} < {stri}")
            del stri

            if line.command == "PING":
                send(f"PONG :{line.params[0]}")

            if mode == "init":
                if line.command == "NOTICE" and line.source != None:
                    if util.maskmatch(line.source, config.server.nickserv_mask):
                        if config.server.nickserv_auth == True:
                            auth()
                if line.command == "433":  # 433 is ERR_NICKNAMEINUSE
                    util.nick(config.self.nick + "_")
                if (
                    line.command == "376" or line.command == "422"
                ):  # 376 is RPL_ENDOFMOTD and 422 is ERR_NOMOTD
                    if config.server.nickserv_auth == True:
                        auth()
                    send(irctokens.build("CAP", ["LS", "302"]).format())
                elif line.command == "CAP" and line.params[1] == "LS":
                    if server_caps == []:
                        server_caps = line.params[2].split()
                    caps = [value for value in wanted_caps if value in server_caps]
                    # single-send is more efficient
                    # BUT a single invalid cap == no caps enabled at all!!!
                    send(irctokens.build("CAP", ["REQ", " ".join(caps)]).format())
                    # for i in caps:
                    #    send(irctokens.build("CAP", ["REQ",i]).format())
                    send(irctokens.build("CAP", ["END"]).format())
                    mode = "boot"
            elif mode == "boot":
                send(irctokens.build("JOIN", [chan]).format())
                mode = "normal"
            elif mode == "normal" and autojoin_done == False:
                try:
                    for channel in config.server.autojoin:
                        send("JOIN " + channel)
                        time.sleep(0.25)
                except Exception:
                    True
                autojoin_done = True
            elif mode == "normal":
                if line.command == "433" and nick_override != False:
                    mesg("nick in use!", chan)
                    util.nick(config.self.nick)
                    nick_override = False
                else:
                    nick_override = False
                if line.command == "INVITE":
                    send(irctokens.build("JOIN", [line.params[1]]).format()) if line.params[1] not in config.server.blacklisted_channels else None
                elif line.command == "PRIVMSG":
                    if line.tags == None or "batch" not in line.tags:
                        is_pm = False
                        is_ctcp = False
                        target = line.params[0]
                        if target == self_nick:
                            target = line.source.split("!")[0]
                            is_pm = True
                        util.target = target
                        command.util.target = target
                        cmd = line.params[1]

                        if cmd != "" and (
                            is_pm
                            or cmd.startswith(self_nick)
                            or cmd[0] in prefixes
                            or "https://" in cmd
                            or "http://" in cmd
                        ):
                            # TODO: allow ignoring hostmasks
                            if line.hostmask.nickname in config.cmd.ignored_nicks:
                                continue
                            try:
                                # if message in a channel, remove prefixes
                                if is_pm:
                                    command.prefix = None
                                else:
                                    if cmd[0] in prefixes:
                                        cmd = cmd.replace(cmd[0], "", 1)
                                        command.prefix = cmd[0]
                                    elif cmd.startswith(self_nick + ":"):
                                        cmd = cmd.replace(self_nick + ":", "", 1)
                                        command.prefix = self_nick
                                    elif cmd.startswith(self_nick):
                                        cmd = cmd.replace(self_nick, "", 1)
                                        command.prefix = self_nick
                                    else:
                                        command.prefix = None
                            except IndexError:
                                continue  # skip to next command
                                cmd = "echo IndexError or something"
                            try:
                                prefix = command.prefix or None
                            except UnboundLocalError or AttributeError:
                                prefix = None
                                command.prefix = prefix
                            cmd = cmd.strip()
                            try:
                                is_adm = (
                                    line.tags["account"] in admin_accounts
                                    or line.source in admin_users
                                )
                            except (
                                KeyError,
                                TypeError,
                            ):  # either no account tag, or no tags at all
                                is_adm = line.source in admin_users

                            # update command module's info dynamically for line info
                            command.util.target = target
                            command._line = line
                            command.is_ctcp = is_ctcp
                            command.pm = is_pm
                            command.line = cmd
                            command.admin = is_adm
                            command.config = config
                            command.self_nick = self_nick
                            command.prefix = prefix

                            if is_adm and cmd.startswith("reload"):
                                (
                                    command,
                                    command.util,
                                    config,
                                    util,
                                    prefixes,
                                    admin_accounts,
                                    admin_users,
                                    admin_only,
                                ) = configure()
                                util.target = target
                                send = util.send
                                command._line = line
                                command.pm = is_pm
                                command.line = cmd
                                command.admin = is_adm
                                command.config = config
                                command.self_nick = self_nick
                                command.prefix = prefix
                                command.util = util
                                command.util.target = target
                                mesg("reloaded")
                            elif (
                                cmd.startswith("eval ")
                                and "eval" not in config.cmd.disabled
                            ):
                                if is_adm:
                                    try:
                                        result = eval(
                                            cmd[len("eval ") :].strip() or "None"
                                        )
                                    except Exception as e:
                                        mesg("Error: " + str(e))
                                else:
                                    mesg("Error: you're not authorized to eval")
                            elif (
                                cmd.startswith("exec ")
                                and "exec" not in config.cmd.disabled
                            ):
                                if is_adm:
                                    try:
                                        result = exec(
                                            cmd[len("exec ") :].strip() or "None"
                                        )
                                    except Exception as e:
                                        mesg("Error: " + str(e))
                                else:
                                    mesg("Error: you're not authorized to exec")

                            # handle normal commands
                            else:
                                command.preq_cmd()