from sopel_SpiceBot_Core_1 import sb


class ComRun():

    def __init__(self, bot, trigger, function, metadata):
        self.bot = bot
        self.orig_trigger = trigger
        self.trigger = trigger
        self.function = function
        self.metadata = metadata
        self._say = []

    @property
    def instigator(self):
        return self.trigger.nick

    @property
    def channel(self):
        return self.trigger.sender

    @property
    def is_in_channel(self):
        return self.channel.startswith("#")

    def say(self, message):
        self._say.append(message)

    def osd(self, messages, recipients=None, text_method='PRIVMSG', max_messages=-1):
        if not recipients:
            recipients = self.trigger.sender
        sb.osd(messages, recipients, text_method, max_messages=-1)

    @property
    def required_privileges(self):
        bot_level = 0
        channel_level = 0

        if "required_privileges" in list(self.metadata.keys()):
            if "bot_level" in list(self.metadata["required_privileges"].keys()):
                bot_level = self.metadata["required_privileges"]["bot_level"]
            if "channel_level" in list(self.metadata["required_privileges"].keys()):
                channel_level = self.metadata["required_privileges"]["channel_level"]

        return {
                "bot": bot_level,
                "channel": channel_level
                }

    @property()
    def required_privileges_text(self):
        ret_text = "This command requries privileges of/above the following"
        if self.required_privileges["bot"]:
            ret_text += " Bot: %s" % sb.users.get_bot_privilege_name(self.required_privileges["bot"])
        if self.required_privileges["channel"] and self.is_in_channel:
            ret_text += " or "
            ret_text += "Channel: %s" % sb.users.get_channel_privilege_name(self.required_privileges["channel"])
        ret_text += "."
        return ret_text

    @property
    def is_nick_privileged(self):
        has_bot_priv = True
        has_channel_priv = True

        priv_dict = self.required_privileges()

        has_bot_priv = sb.users.has_bot_privilege(self.trigger.nick, priv_dict["bot"])

        if self.is_in_channel:
            has_channel_priv = sb.users.has_channel_privilege(self.trigger.nick, self.trigger.sender, priv_dict["channel"])

        if has_bot_priv or has_channel_priv:
            return True
        return False

    @property
    def author(self):
        author = "deathbybandaid"
        if "author" in list(self.metadata.keys()):
            author = self.metadata["author"]
        return author

    @property
    def is_real_command(self):
        return sb.commands.is_real_command(self.command)

    @property
    def command_type(self):
        return sb.commands.what_command_type(self.trigger)

    @property
    def is_catchall(self):
        return sb.commands.is_catchall(self.function, self.command_type)

    @property
    def is_multi_command(self):
        if sb.commands.multi_split_key in self.orig_trigger.args[1]:
            return True
        return False

    @property
    def is_pipe_command(self):
        if sb.commands.pipe_split_key in self.orig_trigger.args[1]:
            return True
        return False

    @property
    def multi_split_count(self):
        if self.is_multi_command:
            return len([x.strip() for x in self.orig_trigger.args[1].split(sb.commands.multi_split_key)])
        return "N/A"

    @property
    def pipe_split_count(self):
        if self.is_pipe_command:
            return len([x.strip() for x in self.orig_trigger.args[1].split(sb.commands.pipe_split_key)])
        return "N/A"

    @property
    def commands(self):
        if self.is_multi_command:
            return sb.commands.get_commands_split(self.orig_trigger, sb.commands.multi_split_key)
        elif self.is_pipe_command:
            return sb.commands.get_commands_split(self.orig_trigger, sb.commands.pipe_split_key)
        else:
            return sb.commands.get_commands_nosplit(self.orig_trigger)

    @property
    def command(self):
        return self.commands[0]

    @property
    def has_command_been_sanitized(self):
        trigger_command = sb.commands.get_command_from_trigger(self.orig_trigger)
        if trigger_command != self.command["trigger_command"]:
            return True
        return False

    @property
    def re_match(self):
        return self.trigger.match