nxy/bot/useless.py

# -*- coding: utf-8 -*-
import random
import re

import irc3
from docopt import Dict
from irc3.plugins.command import command
from irc3.utils import IrcString
from psycopg2 import Error

from . import DatabasePlugin
from .utils import re_generator


class Useless(DatabasePlugin):
    RAINBOW = (5, 7, 8, 9, 3, 10, 12, 2, 6, 13)
    WOAH = (
        'woah',
        'woah indeed',
        'woah woah woah!',
        'keep your woahs to yourself',
    )
    ISPS = (
        't-ipconnect',
        'telefonica',
        'vodafone',
        'kabel',
        'unity-media',
    )
    GENDERS = (
        'male',
        'female',
        'shemale',
        'hermaphrodite',
        'Abimegender',
        'Absorgender',
        'Adamasgender',
        'Adeptogender',
        'Aerogender',
        'Agenderflux',
        'Alexigender',
        'Androgyne',
        'Arifluid',
        'Batgender',
        'Bigender',
        'Bigenderfluid',
        'Biogender',
        'Blizzgender',
        'Boggender',
        'Bordergender/Borderfluid',
        'Boyflux',
        'Burstgende',
        'Cancegender',
        'Chaosgender',
        'Circgender',
        'Cloudgender',
        'Cocoongender',
        'Coigender',
        'Colorgender',
        'Demifluid/flux',
        'Demigender',
        'Digigender',
        'Diurnalgender2',
        'Domgender',
        'Drakefluid',
        'Dryagender',
        'Dulcigender',
        'Duragender',
        'Eafluid',
        'Earthgender',
        'Fuzzgender',
        'Firegender',
        'Genderale',
        'Genderblur',
        'Genderfluid',
        'Gender-Neutral',
        'Gendernegative',
        'Genderpunk',
        'Genderqueer',
        'Kingender',
        'Juxera',
        'Leogender',
        'Invisigender',
        'Intergender',
        'Xirl',
        'Xoy',
        'Xumgender',
        'Zodiacgender',
    )

    @command(permission='admin', show_in_help=False)
    def lowfry(self, mask: IrcString, target: IrcString, args: Dict):
        """Kicks lowfry, most useful command.

        %%lowfry
        """
        self.bot.kick(target, 'lowfry')

    @command(permission='admin', show_in_help=False)
    def kim(self, mask: IrcString, target: IrcString, args: Dict):
        """Kicks kim, most useful command.

        %%kim
        """
        self.bot.kick(target, 'kim')

    @irc3.event(r'(?i)^:(?P<mask>\S+@\S+({})\S+) JOIN :(?P<target>#\S+)$'.format('|'.join(ISPS)))
    def bounce(self, mask, target):
        nick = IrcString(mask).nick

        if target == '#w0bm' and nick != self.bot.nick:
            self.bot.privmsg(target, '{}: Du musst bouncen!'.format(nick))

    @irc3.event(r'(?i)^:\S+ PRIVMSG (?P<target>\S+) :.*(woah|whoa).*$')
    def woah(self, target: str):
        """Colorize words in a sentence with rainbow colors."""
        if random.randint(0, 4) == 0:
            self.bot.privmsg(target, random.choice(self.WOAH))

    @irc3.event(r'(?i)^:\S+ PRIVMSG (?P<target>\S+) :(?P<msg>huehuehue)$')
    def huehuehue(self, target: str, msg: str):
        """Returns a huehuehue when someone writes it."""
        self.bot.privmsg(target, msg)

    @irc3.event(r'(?i)^:\S+ PRIVMSG (?P<target>\S+) :re{{2,}}$')
    def reeeeee(self, target: str):
        """Returns a REEEE."""
        self.bot.privmsg(target, re_generator())

    @irc3.event(r'(?i)^:\S+ PRIVMSG (?P<target>\S+) :same$')
    def same(self, target: str):
        """Returns a plain same when a user writes same."""
        self.bot.privmsg(target, 'same')

    @irc3.event(r'(?i)^:\S+ PRIVMSG (?P<target>\S+) :\[(?P<msg>.*)\]$')
    def intensifies(self, target: str, msg: str):
        """String with brackets around will be returned with INTENSIFIES."""
        self.bot.privmsg(target, '\x02[{} INTENSIFIES]'.format(msg.upper()))

    @command
    def kill(self, mask: IrcString, target: IrcString, args: Dict):
        """Kills a user with a random message

        %%kill [<nick>]
        """
        with self.con.cursor() as cur:
            cur.execute('''
            SELECT
              item
            FROM
              kills
            ORDER BY
              random()
            LIMIT
              1
            ''')
            self.bot.action(target, cur.fetchone()['item'].format(
                nick=args.get('<nick>', mask.nick),
            ))

    @command
    def yiff(self, mask: IrcString, target: IrcString, args: Dict):
        """Yiffs a user with a random message

        %%yiff [<nick>]
        """
        with self.con.cursor() as cur:
            cur.execute('''
            SELECT
              item
            FROM
              yiffs
            ORDER BY
              random()
            LIMIT
              1
            ''')
            self.bot.action(target, cur.fetchone()['item'].format(
                nick=args.get('<nick>', mask.nick),
                yiffer=mask.nick,
            ))

    @command
    def waifu(self, mask: IrcString, target: IrcString, args: Dict):
        """Get waifu for a user (set with prefixing the user with =)

        %%waifu [<nick>...]
        """
        return self.husbando_waifu('waifu', mask, target, args)

    @command
    def husbando(self, mask: IrcString, target: IrcString, args: Dict):
        """Get husbando for a user (set with prefixing the user with =)

        %%husbando [<nick>...]
        """
        return self.husbando_waifu('husbando', mask, target, args)

    @command
    def storyofpomfface(self, mask: IrcString, target: IrcString, args: Dict):
        """Story of pomf face

        %%storyofpomfface
        """
        for face in (':O C==3', ':OC==3', ':C==3', ':C=3', ':C3', ':3'):
            self.bot.privmsg(target, face)

    @command
    def choose(self, mask: IrcString, target: IrcString, args: Dict):
        """Decides between items (separated by comma)

        %%choose <items>...
        """
        choice = random.choice(' '.join(args['<items>']).split(','))
        return '{}: {}'.format(mask.nick, choice.strip())

    @command
    def jn(self, mask: IrcString, target: IrcString, args: Dict):
        """Decides between yes and no (for a question).

        %%jn <question>...
        %%jn
        """
        choice = random.choice(['3Ja', '4Nein'])
        return '{}: \x02\x030{}'.format(mask.nick, choice)

    @command
    def kiss(self, mask: IrcString, target: IrcString, args: Dict):
        """Kisses a user

        %%kiss [<nick>]
        """
        return '(づ｡◕‿‿◕｡)\x0304。。・゜゜・。。・゜❤\x03 {} \x0304❤'.format(args.get('<nick>', mask.nick))

    @command
    def hug(self, mask: IrcString, target: IrcString, args: Dict):
        """Hugs a user

        %%hug [<nick>]
        """
        return '\x0304♥♡❤♡♥\x03 {} \x0304♥♡❤♡♥'.format(args.get('<nick>', mask.nick))

    @command
    def bier(self, mask: IrcString, target: IrcString, args: Dict):
        """Gives a user a beer

        %%bier [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'schenkt ein kühles Blondes an {} aus.'.format(nick))

    @command
    def fucken(self, mask: IrcString, target: IrcString, args: Dict):
        """Kills and fucks a user

        %%fucken [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'fuckt {0} und tötet {0} anschließend.'.format(nick, nick))

    @command(aliases=['anhero', 'sudoku'])
    def seppuku(self, mask: IrcString, target: IrcString, args: Dict):
        """Kicks a user

        %%seppuku
        """
        self.bot.kick(target, mask.nick, 'Sayonara bonzai-chan...')

    @command
    def hack(self, mask: IrcString, target: IrcString, args: Dict):
        """Hacks (a user)

        %%hack [<nick>]
        """
        nick = args.get('<nick>')
        return 'hacking{}...'.format(' %s' % nick if nick else '')

    @command
    def gay(self, mask: IrcString, target: IrcString, args: Dict):
        """Make someone gay (alias to rainbow)

        %%gay <word>...
        """
        return self.rainbow(mask, target, args)

    @command
    def rainbow(self, mask: IrcString, target: IrcString, args: Dict):
        """Colorize a word in rainbow colors

        %%rainbow <word>...
        """
        last = 0
        word = []
        for char in ' '.join(args.get('<word>')):
            if char != ' ':
                char = self._rainbow(last, char)
                last += 1
            word.append(char)
        return ''.join(word)

    @command
    def wrainbow(self, mask: IrcString, target: IrcString, args: Dict):
        """Colorize words in a sentence with rainbow colors

        %%wrainbow <words>...
        """
        return ' '.join([self._rainbow(i, word) for i, word in enumerate(args['<words>'])])

    @command(aliases=['hw'])
    def halfwidth(self, mask: IrcString, target: IrcString, args: Dict):
        """Turns UPPERCASE words into halfwidth characters

        %%halfwidth <words>...
        """

        def replace(match):
            return ''.join(chr(0xFF20 + (ord(c) - 64)) for c in match.group(0))

        return '\x02[HALFWIDTH]\x02 {}'.format(re.sub(r'(?:\b)[A-Z]+(?:\b)', replace, ' '.join(args['<words>'])))

    @command
    def asshole(self, mask: IrcString, target: IrcString, args: Dict):
        """Checks how much of an asshole you are

        %%asshole [<nick>]
        """
        nick = args.get('<nick>', mask.nick)

        if nick.lower() == 'mrhanky':
            perc_min = 100
        elif nick.lower() == 'flummi':
            perc_min = 90
        else:
            perc_min = 0

        asshole_perc = random.randint(perc_min, 100)
        return 'Asshole scan... {} is {}% of an asshole.'.format(nick, asshole_perc)

    @command
    def assume(self, mask: IrcString, target: IrcString, args: Dict):
        """Assumes the gender of a nick or yourself

        %%assume [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        gender = random.choice(self.GENDERS)

        return 'Assuming {}\'s gender... they\'re a {}.'.format(nick, gender)

    @command
    def spit(self, mask: IrcString, target: IrcString, args: Dict):
        """Spits a user

        %%spit [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'spits on {} like a dirty whore.'.format(nick))

    @command
    def merkel(self, mask: IrcString, target: IrcString, args: Dict):
        """Merkels (a user)

        %%merkel [<nick>]
        """
        return '{}, wir schaffen das!'.format(args.get('<nick>', mask.nick))

    @command
    def assel(self, mask: IrcString, target: IrcString, args: Dict):
          """Asselt a user

          %%assel [<nick>]
          """
          nick = args.get('<nick>', mask.nick)
          self.bot.action(target, 'asselt {0}'.format(nick, nick))

    @command
    def gurke(self, mask: IrcString, target: IrcString, args: Dict):
        """Gurks a user

        %%gurke [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'schiebt {0} eine Gurke in den Arsch'.format(nick, nick))

    @command
    def kacken(self, mask: IrcString, target: IrcString, args: Dict):
        """wünscht guten rutsch beim kacken

        %%kacken [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'wünscht {0} einen guten Rutsch! Nicht zu fest drücken!'.format(nick, nick))

    @command
    def knoblauch(self, mask: IrcString, target: IrcString, args: Dict):
        """knoblaucht einen user

        %%knoblauch [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'schneidet etwas Knoblauch klein und lässt die Stückchen in den Arsch von {0} fallen.'.format(nick, nick))

    @command
    def zaziki(self, mask: IrcString, target: IrcString, args: Dict):
        """zaziki

        %%zaziki [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'bereitet in dem Arsch von {0} ein frisches Zaziki nach original griechischem Rezept zu.'.format(nick, nick))

    @command
    def biene(self, mask: IrcString, target: IrcString, args: Dict):
        """biene

        %%biene [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'sticht mit letzter Lebenskraft in die Eichel von {0} und stirbt dann.'.format(nick, nick))

    @command
    def wespe(self, mask: IrcString, target: IrcString, args: Dict):
        """wespe

        %%wespe [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'sticht tausende male auf {0} ein und fliegt dann weg als wäre nichts gewesen'.format(nick, nick))

    @command
    def saufen(self, mask: IrcString, target: IrcString, args: Dict):
        """fordert einen Nutzer zum Saufgelage auf!

        %%saufen [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'fordert {0} zum saufen auf!'.format(nick, nick))

    @command
    def jalapeno(self, mask: IrcString, target: IrcString, args: Dict):
        """schiebt eine jalapeno in die harnröhre eines nutzers

        %%jalapeno [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'schiebt {0} eine Jalapeno in die Harnröhre'.format(nick, nick))

    @command
    def schwulmo(self, mask: IrcString, target: IrcString, args: Dict):
        """schwulmot den kompletten Channel!

        %%schwulmo [<nick>]
        """
        self.bot.action(target, 'wünscht einen tollen schwulmo an alle :********')

    @command
    def iframe(self, mask: IrcString, target: IrcString, args: Dict):
        """ddoses someone with an iframe!

        %%iframe [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'starts a low skilled, fuuuf like iframe ddos attack on {0}'.format(nick, nick))

    @command
    def corona(self, mask: IrcString, target: IrcString, args: Dict):
        """infects someone with corona

        %%corona [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'hustet {0} in\'s Gesicht'.format(nick, nick))

    @command
    def vampir(self, mask: IrcString, target: IrcString, args: Dict):
        """Sends a url with the cute vampire cat :3
        
        %%vampir
        """
        return 'https://files.catbox.moe/ma2dfs.png'

    @command
    def hebamme(self, mask: IrcString, target: IrcString, args: Dict):
        """Tells you to get the fuck outta this group
        
        %%hebamme [<nick>]
        """
        nick = args.get('<nick>', mask.nick)
        self.bot.action(target, 'macht {0} klar, dass er sich lieber verpissen sollte!'.format(nick, nick))

    def husbando_waifu(self, field: str, mask: IrcString, target: IrcString, args: Dict):
        nick = args.get('<nick>', mask.nick)
        if isinstance(nick, list):
            nick = ' '.join(nick)

        if nick.startswith('='):
            nick = nick[1:]

            try:
                with self.con.cursor() as cur:
                    cur.execute('''
                        INSERT INTO
                          users (nick, {0})
                        VALUES
                          (lower(%s), %s)
                        ON CONFLICT (nick) DO UPDATE SET
                          {0} = excluded.{0}
                        '''.format(field), [mask.nick, nick])
                self.con.commit()

                self.bot.notice(mask.nick, '{} set to: {}'.format(field.title(), nick))
            except Error as ex:
                self.log.error(ex)
                self.con.rollback()
        else:
            with self.con.cursor() as cur:
                cur.execute('''
                    SELECT
                      {}
                    FROM
                      users
                    WHERE
                      lower(nick) = lower(%s)
                    '''.format(field), [nick])
                result = cur.fetchone()

            if result and result[field]:
                return '\x02[{}]\x02 {}: {}'.format(field.title(), nick, result[field])

    # noinspection PyMethodMayBeStatic
    def _rainbow(self, i, char):
        return '\x03{0:02d}{1}'.format(self.RAINBOW[i % len(self.RAINBOW)], char)