/++
    Awareness mixins, for plugins to mix in to extend behaviour and enjoy a
    considerable degree of automation.

    These are used for plugins to mix in book-keeping of users and channels.

    Example:
    ---
    import kameloso.plugins.common.core;
    import kameloso.plugins.common.awareness;

    @Settings struct FooSettings { /* ... */ }

    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.CHAN)
        .permissionsRequired(Permissions.anyone)
        .channelPolicy(ChannelPolicy.home)
        .addCommand(
            IRCEventHandler.Command()
                .word("foo")
                .policy(PrefixPolicy.prefixed)
        )
    )
    void onFoo(FooPlugin plugin, const ref IRCEvent event)
    {
        // ...
    }

    mixin UserAwareness;
    mixin ChannelAwareness;

    final class FooPlugin : IRCPlugin
    {
        FooSettings fooSettings;

        // ...

        mixin IRCPluginImpl;
    }
    ---

    See_Also:
        [kameloso.plugins.common.core],
        [kameloso.plugins.common.misc]

    Copyright: [JR](https://github.com/zorael)
    License: [Boost Software License 1.0](https://www.boost.org/users/license.html)

    Authors:
        [JR](https://github.com/zorael)
 +/
module kameloso.plugins.common.awareness;

private:

import kameloso.plugins.common.core;
import dialect.defs;
import std.typecons : Flag, No, Yes;

public:

@safe:


// MinimalAuthentication
/++
    Implements triggering of queued events in a plugin module, based on user details
    such as account or hostmask.

    Most of the time a plugin doesn't require a full
    [kameloso.plugins.common.awareness.UserAwareness|UserAwareness]; only
    those that need looking up users outside of the current event do. The
    persistency service allows for plugins to just read the information from
    the [dialect.defs.IRCUser|IRCUser] embedded in the event directly, and that's
    often enough.

    General rule: if a plugin doesn't access
    [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users],
    it's probably going to be enough with only
    [kameloso.plugins.common.awareness.MinimalAuthentication|MinimalAuthentication].

    Params:
        debug_ = Whether or not to include debugging output.
        module_ = String name of the mixing-in module; generally leave as-is.

    See_Also:
        [kameloso.plugins.common.awareness.UserAwareness|UserAwareness]
        [kameloso.plugins.common.awareness.ChannelAwareness|ChannelAwareness]
 +/
mixin template MinimalAuthentication(
    Flag!"debug_" debug_ = No.debug_,
    string module_ = __MODULE__)
{
    private import dialect.defs : IRCEvent;
    private static import kameloso.plugins.common.awareness;

    /++
        Flag denoting that
        [kameloso.plugins.common.awareness.MinimalAuthentication|MinimalAuthentication]
        has been mixed in.
     +/
    package enum hasMinimalAuthentication = true;

    // onMinimalAuthenticationAccountInfoTargetMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onMinimalAuthenticationAccountInfoTarget|onMinimalAuthenticationAccountInfoTarget].

        See_Also:
            [kameloso.plugins.common.awareness.onMinimalAuthenticationAccountInfoTarget|onMinimalAuthenticationAccountInfoTarget]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.RPL_WHOISACCOUNT)
        .onEvent(IRCEvent.Type.RPL_WHOISREGNICK)
        .onEvent(IRCEvent.Type.RPL_ENDOFWHOIS)
        .when(Timing.early)
        .chainable(true)
    )
    void onMinimalAuthenticationAccountInfoTargetMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onMinimalAuthenticationAccountInfoTarget(plugin, event);
    }

    // onMinimalAuthenticationUnknownCommandWHOISMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onMinimalAuthenticationUnknownCommandWHOIS|onMinimalAuthenticationUnknownCommandWHOIS].

        See_Also:
            [kameloso.plugins.common.awareness.onMinimalAuthenticationUnknownCommandWHOIS|onMinimalAuthenticationUnknownCommandWHOIS]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.ERR_UNKNOWNCOMMAND)
        .when(Timing.early)
        .chainable(true)
    )
    void onMinimalAuthenticationUnknownCommandWHOIS(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onMinimalAuthenticationUnknownCommandWHOIS(plugin, event);
    }
}


// onMinimalAuthenticationAccountInfoTarget
/++
    Replays any queued [kameloso.plugins.common.core.Replay|Replay]s awaiting the result
    of a WHOIS query. Before that, records the user's services account by
    saving it to the user's [dialect.defs.IRCClient|IRCClient] in the
    [kameloso.plugins.common.core.IRCPlugin|IRCPlugin]'s
    [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users] associative array.

    [dialect.defs.IRCEvent.Type.RPL_ENDOFWHOIS] is also handled, to
    cover the case where a user without an account triggering
    [kameloso.plugins.common.core.Permissions.anyone|Permissions.anyone]- or
    [kameloso.plugins.common.core.Permissions.ignore|Permissions.ignore]-level commands.

    This function was part of [UserAwareness] but triggering queued replays
    is too common to conflate with it.
 +/
void onMinimalAuthenticationAccountInfoTarget(IRCPlugin plugin, const ref IRCEvent event) @system
{
    import kameloso.plugins.common.misc : catchUser;

    // Catch the user here, before replaying anything.
    catchUser(plugin, event.target);

    // See if there are any queued replays to trigger
    auto replaysForNickname = event.target.nickname in plugin.state.pendingReplays;
    if (!replaysForNickname) return;

    scope(exit)
    {
        plugin.state.pendingReplays.remove(event.target.nickname);
        plugin.state.hasPendingReplays = (plugin.state.pendingReplays.length > 0);
    }

    if (!replaysForNickname.length) return;

    foreach (immutable i, replay; *replaysForNickname)
    {
        import kameloso.constants : Timeout;

        if ((event.time - replay.timestamp) >= Timeout.whoisDiscard)
        {
            // Stale entry
        }
        else
        {
            plugin.state.readyReplays ~= replay;
        }
    }
}


// onMinimalAuthenticationUnknownCommandWHOIS
/++
    Clears all queued [kameloso.plugins.common.core.Replay|Replay]s if the server
    says it doesn't support WHOIS at all.

    This is the case with Twitch servers.
 +/
void onMinimalAuthenticationUnknownCommandWHOIS(IRCPlugin plugin, const ref IRCEvent event) @system
{
    if (event.aux[0] != "WHOIS") return;

    // We're on a server that doesn't support WHOIS
    // Trigger queued replays of a Permissions.anyone nature, since
    // they're just Permissions.ignore plus a WHOIS lookup just in case
    // Then clear everything

    foreach (replaysForNickname; plugin.state.pendingReplays)
    {
        foreach (replay; replaysForNickname)
        {
            plugin.state.readyReplays ~= replay;
        }
    }

    plugin.state.pendingReplays.clear();
    plugin.state.hasPendingReplays = false;
}


// UserAwareness
/++
    Implements *user awareness* in a plugin module.

    This maintains a cache of all currently visible users, adding people to it
    upon discovering them and best-effort culling them when they leave or quit.
    The cache kept is an associative array, in
    [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users].

    User awareness implicitly requires
    [kameloso.plugins.common.awareness.MinimalAuthentication|minimal authentication]
    and will silently include it if it was not already mixed in.

    Params:
        channelPolicy = What [kameloso.plugins.common.core.ChannelPolicy|ChannelPolicy]
            to apply to enwrapped event handlers.
        debug_ = Whether or not to include debugging output.
        module_ = String name of the mixing-in module; generally leave as-is.

    See_Also:
        [kameloso.plugins.common.awareness.MinimalAuthentication|MinimalAuthentication]
        [kameloso.plugins.common.awareness.ChannelAwareness|ChannelAwareness]
 +/
mixin template UserAwareness(
    ChannelPolicy channelPolicy = ChannelPolicy.home,
    Flag!"debug_" debug_ = No.debug_,
    string module_ = __MODULE__)
{
    private import dialect.defs : IRCEvent;
    private static import kameloso.plugins.common.awareness;

    /++
        Flag denoting that
        [kameloso.plugins.common.awareness.UserAwareness|UserAwareness]
        has been mixed in.
     +/
    package enum hasUserAwareness = true;

    static if (!__traits(compiles, { alias _ = .hasMinimalAuthentication; }))
    {
        mixin kameloso.plugins.common.awareness.MinimalAuthentication!(debug_, module_);
    }

    // onUserAwarenessQuitMixin
    /++
        Proxies to [kameloso.plugins.common.awareness.onUserAwarenessQuit|onUserAwarenessQuit].

        See_Also:
            [kameloso.plugins.common.awareness.onUserAwarenessQuit|onUserAwarenessQuit]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.QUIT)
        .when(Timing.cleanup)
        .chainable(true)
    )
    void onUserAwarenessQuitMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onUserAwarenessQuit(plugin, event);
    }

    // onUserAwarenessNickMixin
    /++
        Proxies to [kameloso.plugins.common.awareness.onUserAwarenessNick|onUserAwarenessNick].

        See_Also:
            [kameloso.plugins.common.awareness.onUserAwarenessNick|onUserAwarenessNick]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.NICK)
        .when(Timing.early)
        .chainable(true)
    )
    void onUserAwarenessNickMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onUserAwarenessNick(plugin, event);
    }

    // onUserAwarenessCatchTargetMixin
    /++
        Proxies to [kameloso.plugins.common.awareness.onUserAwarenessCatchTarget|onUserAwarenessCatchTarget].

        See_Also:
            [kameloso.plugins.common.awareness.onUserAwarenessCatchTarget|onUserAwarenessCatchTarget]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.RPL_WHOISUSER)
        .onEvent(IRCEvent.Type.RPL_WHOREPLY)
        /*.onEvent(IRCEvent.Type.RPL_WHOISACCOUNT)
        .onEvent(IRCEvent.Type.RPL_WHOISREGNICK)*/  // Caught in MinimalAuthentication
        .onEvent(IRCEvent.Type.CHGHOST)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onUserAwarenessCatchTargetMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onUserAwarenessCatchTarget(plugin, event);
    }

    // onUserAwarenessCatchSenderMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onUserAwarenessCatchSender|onUserAwarenessCatchSender].

        See_Also:
            [kameloso.plugins.common.awareness.onUserAwarenessCatchSender|onUserAwarenessCatchSender]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.JOIN)
        .onEvent(IRCEvent.Type.ACCOUNT)
        .onEvent(IRCEvent.Type.AWAY)
        .onEvent(IRCEvent.Type.BACK)
        /*.onEvent(IRCEvent.Type.CHAN)  // Avoid these to be lean; everyone gets indexed by WHO anyway
        .onEvent(IRCEvent.Type.EMOTE)*/ // ...except on Twitch, but TwitchAwareness has these annotations
        .channelPolicy(channelPolicy)
        .when(Timing.setup)
        .chainable(true)
    )
    void onUserAwarenessCatchSenderMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onUserAwarenessCatchSender!channelPolicy(plugin, event);
    }

    // onUserAwarenessNamesReplyMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onUserAwarenessNamesReply|onUserAwarenessNamesReply].

        See_Also:
            [kameloso.plugins.common.awareness.onUserAwarenessNamesReply|onUserAwarenessNamesReply]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.RPL_NAMREPLY)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onUserAwarenessNamesReplyMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onUserAwarenessNamesReply(plugin, event);
    }

    // onUserAwarenessEndOfListMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onUserAwarenessEndOfList|onUserAwarenessEndOfList].

        See_Also:
            [kameloso.plugins.common.awareness.onUserAwarenessEndOfList|onUserAwarenessEndOfList]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.RPL_ENDOFNAMES)
        .onEvent(IRCEvent.Type.RPL_ENDOFWHO)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onUserAwarenessEndOfListMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onUserAwarenessEndOfList(plugin, event);
    }

    // onUserAwarenessPingMixin
    /++
        Proxies to [kameloso.plugins.common.awareness.onUserAwarenessPing|onUserAwarenessPing].

        See_Also:
            [kameloso.plugins.common.awareness.onUserAwarenessPing|onUserAwarenessPing]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.PING)
        .when(Timing.early)
        .chainable(true)
    )
    void onUserAwarenessPingMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onUserAwarenessPing(plugin, event);
    }
}


// onUserAwarenessQuit
/++
    Removes a user's [dialect.defs.IRCUser|IRCUser] entry from a plugin's user
    list upon them disconnecting.
 +/
void onUserAwarenessQuit(IRCPlugin plugin, const ref IRCEvent event)
{
    plugin.state.users.remove(event.sender.nickname);
}


// onUserAwarenessNick
/++
    Upon someone changing nickname, update their entry in the
    [kameloso.plugins.common.core.IRCPlugin|IRCPlugin]'s
    [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users]
    array to point to the new nickname.

    Removes the old entry after assigning it to the new key.
 +/
void onUserAwarenessNick(IRCPlugin plugin, const ref IRCEvent event)
{
    if (plugin.state.settings.preferHostmasks)
    {
        // Persistence will have set up a complete user with account and everything.
        // There's no point in copying anything over.
    }
    else if (auto oldUser = event.sender.nickname in plugin.state.users)
    {
        plugin.state.users[event.target.nickname] = *oldUser;
    }

    plugin.state.users.remove(event.sender.nickname);
}


// onUserAwarenessCatchTarget
/++
    Catches a user's information and saves it in the plugin's
    [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users]
    array of [dialect.defs.IRCUser|IRCUser]s.

    [dialect.defs.IRCEvent.Type.RPL_WHOISUSER] events carry values in
    the [dialect.defs.IRCUser.updated|IRCUser.updated] field that we want to store.

    [dialect.defs.IRCEvent.Type.CHGHOST] occurs when a user changes host
    on some servers that allow for custom host addresses.
 +/
void onUserAwarenessCatchTarget(IRCPlugin plugin, const ref IRCEvent event)
{
    import kameloso.plugins.common.misc : catchUser;
    catchUser(plugin, event.target);
}


// onUserAwarenessCatchSender
/++
    Adds a user to the [kameloso.plugins.common.core.IRCPlugin|IRCPlugin]'s
    [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users] array,
    potentially including their services account name.

    Servers with the (enabled) capability `extended-join` will include the
    account name of whoever joins in the event string. If it's there, catch
    the user into the user array so we don't have to WHOIS them later.
 +/
void onUserAwarenessCatchSender(ChannelPolicy channelPolicy)
    (IRCPlugin plugin, const ref IRCEvent event)
{
    import kameloso.plugins.common.misc : catchUser;

    with (IRCEvent.Type)
    switch (event.type)
    {
    case ACCOUNT:
    case AWAY:
    case BACK:
        static if (channelPolicy == ChannelPolicy.home)
        {
            // These events don't carry a channel.
            // Catch if there's already an entry. Trust that it's supposed
            // to be there if it's there. (RPL_NAMREPLY probably populated it)

            if (event.sender.nickname in plugin.state.users)
            {
                catchUser(plugin, event.sender);
                break;
            }

            static if (__traits(compiles, { alias _ = .hasChannelAwareness; }))
            {
                // Catch the user if it's visible in some channel we're in.

                foreach (const channel; plugin.state.channels)
                {
                    if (event.sender.nickname in channel.users)
                    {
                        // event is from a user that's in a relevant channel
                        return catchUser(plugin, event.sender);
                    }
                }
            }
        }
        else /*static if (channelPolicy == ChannelPolicy.any)*/
        {
            // Catch everyone on ChannelPolicy.any
            catchUser(plugin, event.sender);
        }
        break;

    //case JOIN:
    default:
        return catchUser(plugin, event.sender);
    }
}


// onUserAwarenessNamesReply
/++
    Catch users in a reply for the request for a NAMES list of all the
    participants in a channel.

    Freenode only sends a list of the nicknames but SpotChat sends the full
    `user!ident@address` information.
 +/
void onUserAwarenessNamesReply(IRCPlugin plugin, const ref IRCEvent event)
{
    import kameloso.plugins.common.misc : catchUser;
    import kameloso.irccolours : stripColours;
    import dialect.common : IRCControlCharacter, stripModesign;
    import lu.string : contains, nom;
    import std.algorithm.iteration : splitter;

    if (plugin.state.server.daemon == IRCServer.Daemon.twitch)
    {
        // Do nothing actually. Twitch NAMES is unreliable noise.
        return;
    }

    auto names = event.content.splitter(' ');

    foreach (immutable userstring; names)
    {
        string slice = userstring;  // mutable
        IRCUser user;

        if (!slice.contains('!'))
        {
            // No need to check for slice.contains('@'))
            // Freenode-like, only nicknames with possible modesigns
            immutable nickname = slice.stripModesign(plugin.state.server);
            if (nickname == plugin.state.client.nickname) continue;
            user.nickname = nickname;
        }
        else
        {
            // SpotChat-like, names are in full nick!ident@address form
            immutable signed = slice.nom('!');
            immutable nickname = signed.stripModesign(plugin.state.server);
            if (nickname == plugin.state.client.nickname) continue;
            immutable ident = slice.nom('@');

            // Do addresses ever contain bold, italics, underlined?
            immutable address = slice.contains(IRCControlCharacter.colour) ?
                stripColours(slice) :
                slice;

            user = IRCUser(nickname, ident, address);
        }

        catchUser(plugin, user);  // this melds with the default conservative strategy
    }
}


// onUserAwarenessEndOfList
/++
    Rehashes, or optimises, the [kameloso.plugins.common.core.IRCPlugin|IRCPlugin]'s
    [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users]
    associative array upon the end of a WHO or a NAMES list.

    These replies can list hundreds of users depending on the size of the
    channel. Once an associative array has grown sufficiently, it becomes
    inefficient. Rehashing it makes it take its new size into account and
    makes lookup faster.
 +/
void onUserAwarenessEndOfList(IRCPlugin plugin, const ref IRCEvent event) @system
{
    import kameloso.plugins.common.misc : rehashUsers;

    // Pass a channel name so only that channel is rehashed
    rehashUsers(plugin, event.channel);
}


// onUserAwarenessPingMixin
/++
    Rehash the internal [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users]
    associative array of [dialect.defs.IRCUser|IRCUser]s, once every
    [kameloso.constants.Periodicals.userAARehashMinutes|Periodicals.userAARehashMinutes] minutes.

    We ride the periodicity of [dialect.defs.IRCEvent.Type.PING|PING] to get
    a natural cadence without having to resort to queued
    [kameloso.thread.ScheduledFiber|ScheduledFiber]s.

    The number of hours is so far hardcoded but can be made configurable if
    there's a use-case for it.
 +/
void onUserAwarenessPing(IRCPlugin plugin, const ref IRCEvent event) @system
{
    import std.datetime.systime : Clock;

    enum minutesBeforeInitialRehash = 5;

    static long pingRehash;

    if (pingRehash == 0L)
    {
        // First PING encountered
        // Delay rehashing to let the client join all channels
        pingRehash = event.time + (minutesBeforeInitialRehash * 60);
    }
    else if (event.time >= pingRehash)
    {
        import kameloso.constants : Periodicals;
        import kameloso.plugins.common.misc : rehashUsers;

        // Once every `userAARehashMinutes` minutes, rehash the `users` array.
        rehashUsers(plugin);
        pingRehash = event.time + (Periodicals.userAARehashMinutes * 60);
    }
}


// ChannelAwareness
/++
    Implements *channel awareness* in a plugin module.

    This maintains a cache of all current channels, their topics and modes, and
    their participants. The cache kept is an associative array, in
    [kameloso.plugins.common.core.IRCPluginState.channels|IRCPluginState.channels].

    Channel awareness explicitly requires
    [kameloso.plugins.common.awareness.UserAwareness|user awareness] and will
    halt compilation if it is not also mixed in.

    Params:
        channelPolicy = What [kameloso.plugins.common.core.ChannelPolicy|ChannelPolicy]
            to apply to enwrapped event handlers.
        debug_ = Whether or not to include debugging output.
        module_ = String name of the mixing-in module; generally leave as-is.

    See_Also:
        [kameloso.plugins.common.awareness.MinimalAuthentication|MinimalAuthentication]
        [kameloso.plugins.common.awareness.UserAwareness|UserAwareness]
 +/
mixin template ChannelAwareness(
    ChannelPolicy channelPolicy = ChannelPolicy.home,
    Flag!"debug_" debug_ = No.debug_,
    string module_ = __MODULE__)
{
    private import dialect.defs : IRCEvent;
    private static import kameloso.plugins.common.awareness;

    /++
        Flag denoting that [kameloso.plugins.common.awareness.ChannelAwareness|ChannelAwareness]
        has been mixed in.
     +/
    package enum hasChannelAwareness = true;

    static if (!__traits(compiles, { alias _ = .hasUserAwareness; }))
    {
        import std.format : format;

        enum pattern = "`%s` is missing a `UserAwareness` mixin " ~
            "(needed for `ChannelAwareness`)";
        enum message = pattern.format(module_);
        static assert(0, message);
    }

    // onChannelAwarenessSelfjoinMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onChannelAwarenessSelfjoin|onChannelAwarenessSelfjoin].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessSelfjoin|onChannelAwarenessSelfjoin]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.SELFJOIN)
        .channelPolicy(channelPolicy)
        .when(Timing.setup)
        .chainable(true)
    )
    void onChannelAwarenessSelfjoinMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessSelfjoin(plugin, event);
    }

    // onChannelAwarenessSelfpartMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onChannelAwarenessSelfpart|onChannelAwarenessSelfpart].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessSelfpart|onChannelAwarenessSelfpart]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.SELFPART)
        .onEvent(IRCEvent.Type.SELFKICK)
        .channelPolicy(channelPolicy)
        .when(Timing.cleanup)
        .chainable(true)
    )
    void onChannelAwarenessSelfpartMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessSelfpart(plugin, event);
    }

    // onChannelAwarenessJoinMixin
    /++
        Proxies to [kameloso.plugins.common.awareness.onChannelAwarenessJoin|onChannelAwarenessJoin].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessJoin|onChannelAwarenessJoin]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.JOIN)
        .channelPolicy(channelPolicy)
        .when(Timing.setup)
        .chainable(true)
    )
    void onChannelAwarenessJoinMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessJoin(plugin, event);
    }

    // onChannelAwarenessPartMixin
    /++
        Proxies to [kameloso.plugins.common.awareness.onChannelAwarenessPart|onChannelAwarenessPart].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessPart|onChannelAwarenessPart]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.PART)
        .channelPolicy(channelPolicy)
        .when(Timing.late)
        .chainable(true)
    )
    void onChannelAwarenessPartMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessPart(plugin, event);
    }

    // onChannelAwarenessNickMixin
    /++
        Proxies to [kameloso.plugins.common.awareness.onChannelAwarenessNick|onChannelAwarenessNick].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessNick|onChannelAwarenessNick]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.NICK)
        .when(Timing.setup)
        .chainable(true)
    )
    void onChannelAwarenessNickMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessNick(plugin, event);
    }

    // onChannelAwarenessQuitMixin
    /++
        Proxies to [kameloso.plugins.common.awareness.onChannelAwarenessQuit|onChannelAwarenessQuit].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessQuit|onChannelAwarenessQuit]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.QUIT)
        .when(Timing.late)
        .chainable(true)
    )
    void onChannelAwarenessQuitMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessQuit(plugin, event);
    }

    // onChannelAwarenessTopicMixin
    /++
        Proxies to [kameloso.plugins.common.awareness.onChannelAwarenessTopic|onChannelAwarenessTopic].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessTopic|onChannelAwarenessTopic]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.TOPIC)
        .onEvent(IRCEvent.Type.RPL_TOPIC)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onChannelAwarenessTopicMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessTopic(plugin, event);
    }

    // onChannelAwarenessCreationTimeMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onChannelAwarenessCreationTime|onChannelAwarenessCreationTime].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessCreationTime|onChannelAwarenessCreationTime]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.RPL_CREATIONTIME)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onChannelAwarenessCreationTimeMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessCreationTime(plugin, event);
    }

    // onChannelAwarenessModeMixin
    /++
        Proxies to [kameloso.plugins.common.awareness.onChannelAwarenessMode|onChannelAwarenessMode].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessMode|onChannelAwarenessMode]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.MODE)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onChannelAwarenessModeMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessMode(plugin, event);
    }

    // onChannelAwarenessWhoReplyMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onChannelAwarenessWhoReply|onChannelAwarenessWhoReply].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessWhoReply|onChannelAwarenessWhoReply]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.RPL_WHOREPLY)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onChannelAwarenessWhoReplyMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessWhoReply(plugin, event);
    }

    // onChannelAwarenessNamesReplyMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onChannelAwarenessNamesReply|onChannelAwarenessNamesReply].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessNamesReply|onChannelAwarenessNamesReply]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.RPL_NAMREPLY)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onChannelAwarenessNamesReplyMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessNamesReply(plugin, event);
    }

    // onChannelAwarenessModeListsMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onChannelAwarenessModeLists|onChannelAwarenessModeLists].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessModeLists|onChannelAwarenessModeLists]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.RPL_BANLIST)
        .onEvent(IRCEvent.Type.RPL_EXCEPTLIST)
        .onEvent(IRCEvent.Type.RPL_INVITELIST)
        .onEvent(IRCEvent.Type.RPL_REOPLIST)
        .onEvent(IRCEvent.Type.RPL_QUIETLIST)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onChannelAwarenessModeListsMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessModeLists(plugin, event);
    }

    // onChannelAwarenessChannelModeIsMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onChannelAwarenessChannelModeIs|onChannelAwarenessChannelModeIs].

        See_Also:
            [kameloso.plugins.common.awareness.onChannelAwarenessChannelModeIs|onChannelAwarenessChannelModeIs]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.RPL_CHANNELMODEIS)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onChannelAwarenessChannelModeIsMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onChannelAwarenessChannelModeIs(plugin, event);
    }
}


// onChannelAwarenessSelfjoin
/++
    Create a new [dialect.defs.IRCChannel|IRCChannel] in the the
    [kameloso.plugins.common.core.IRCPlugin|IRCPlugin]'s
    [kameloso.plugins.common.core.IRCPluginState.channels|IRCPluginState.channels]
    associative array when the bot joins a channel.
 +/
void onChannelAwarenessSelfjoin(IRCPlugin plugin, const ref IRCEvent event)
{
    if (event.channel in plugin.state.channels) return;

    plugin.state.channels[event.channel] = IRCChannel.init;
    plugin.state.channels[event.channel].name = event.channel;
}


// onChannelAwarenessSelfpart
/++
    Removes an [dialect.defs.IRCChannel|IRCChannel] from the internal list when the
    bot leaves it.

    Remove users from the [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users]
    array if, by leaving, it left the last channel we can observe it from, so as
    not to leak users. It can be argued that this should be part of user awareness,
    however this would not be possible if it were not for channel-tracking.
    As such keep the behaviour in channel awareness.
 +/
void onChannelAwarenessSelfpart(IRCPlugin plugin, const ref IRCEvent event)
{
    // On Twitch SELFPART may occur on untracked channels
    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    nickloop:
    foreach (immutable nickname; channel.users.byKey)
    {
        foreach (immutable stateChannelName, const stateChannel; plugin.state.channels)
        {
            if (stateChannelName == event.channel) continue;
            if (nickname in stateChannel.users) continue nickloop;
        }

        // nickname is not in any of our other tracked channels; remove
        plugin.state.users.remove(nickname);
    }

    plugin.state.channels.remove(event.channel);
}


// onChannelAwarenessJoin
/++
    Adds a user as being part of a channel when they join it.
 +/
void onChannelAwarenessJoin(IRCPlugin plugin, const ref IRCEvent event)
{
    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    channel.users[event.sender.nickname] = true;
}


// onChannelAwarenessPart
/++
    Removes a user from being part of a channel when they leave it.

    Remove the user from the [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users]
    array if, by leaving, it left the last channel we can observe it from, so as
    not to leak users. It can be argued that this should be part of user awareness,
    however this would not be possible if it were not for channel-tracking.
    As such keep the behaviour in channel awareness.
 +/
void onChannelAwarenessPart(IRCPlugin plugin, const ref IRCEvent event)
{
    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    if (event.sender.nickname !in channel.users)
    {
        // On Twitch servers with no NAMES on joining a channel, users
        // that you haven't seen may leave despite never having been seen
        return;
    }

    channel.users.remove(event.sender.nickname);

    // Remove entries in the mods AA (ops, halfops, voice, ...)
    foreach (/*immutable prefixChar,*/ ref prefixMods; channel.mods)
    {
        foreach (immutable modNickname, _; prefixMods)
        {
            prefixMods.remove(event.sender.nickname);
        }
    }

    foreach (const foreachChannel; plugin.state.channels)
    {
        if (event.sender.nickname in foreachChannel.users) return;
    }

    // event.sender is not in any of our tracked channels; remove
    plugin.state.users.remove(event.sender.nickname);
}


// onChannelAwarenessNick
/++
    Upon someone changing nickname, update their entry in the
    [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users]
    associative array to point to the new nickname.

    Does *not* add a new entry if one doesn't exits, to counter the fact
    that [dialect.defs.IRCEvent.Type.NICK] events don't belong to a channel,
    and as such can't be regulated with [kameloso.plugins.common.core.ChannelPolicy|ChannelPolicy]
    annotations. This way the user will only be moved if it was already added elsewhere.
    Else we'll leak users.

    Removes the old entry after assigning it to the new key.
 +/
void onChannelAwarenessNick(IRCPlugin plugin, const ref IRCEvent event)
{
    // User awareness bits take care of the IRCPluginState.users AA

    foreach (ref channel; plugin.state.channels)
    {
        if (event.sender.nickname !in channel.users) continue;

        channel.users.remove(event.sender.nickname);
        channel.users[event.target.nickname] = true;
    }
}


// onChannelAwarenessQuit
/++
    Removes a user from all tracked channels if they disconnect.

    Does not touch the internal list of users; the user awareness bits are
    expected to take care of that.
 +/
void onChannelAwarenessQuit(IRCPlugin plugin, const ref IRCEvent event)
{
    foreach (ref channel; plugin.state.channels)
    {
        channel.users.remove(event.sender.nickname);
    }
}


// onChannelAwarenessTopic
/++
    Update the entry for an [dialect.defs.IRCChannel|IRCChannel] if someone changes
    the topic of it.
 +/
void onChannelAwarenessTopic(IRCPlugin plugin, const ref IRCEvent event)
{
    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    channel.topic = event.content;  // don't strip
}


// onChannelAwarenessCreationTime
/++
    Stores the timestamp of when a channel was created.
 +/
void onChannelAwarenessCreationTime(IRCPlugin plugin, const ref IRCEvent event)
{
    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    channel.created = event.count[0].get;
}


// onChannelAwarenessMode
/++
    Sets a mode for a channel.

    Most modes replace others of the same type, notable exceptions being
    bans and mode exemptions. We let [dialect.common.setMode] take care of that.
 +/
void onChannelAwarenessMode(IRCPlugin plugin, const ref IRCEvent event)
{
    version(TwitchSupport)
    {
        if (plugin.state.server.daemon == IRCServer.Daemon.twitch)
        {
            // Twitch modes are unpredictable. Ignore and rely on badges instead.
            return;
        }
    }

    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    import dialect.common : setMode;
    (*channel).setMode(event.aux[0], event.content, plugin.state.server);
}


// onChannelAwarenessWhoReply
/++
    Adds a user as being part of a channel upon receiving the reply from the
    request for info on all the participants.

    This events includes all normal fields like ident and address, but not
    their channel modes (e.g. `@` for operator).
 +/
void onChannelAwarenessWhoReply(IRCPlugin plugin, const ref IRCEvent event)
{
    import std.string : representation;

    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    // User awareness bits add the IRCUser
    if (event.aux[0].length)
    {
        // Register operators, half-ops, voiced etc
        // Can be more than one if multi-prefix capability is enabled
        // Server-sent string, can assume ASCII (@,%,+...) and go char by char
        foreach (immutable modesign; event.aux[0].representation)
        {
            if (const modechar = modesign in plugin.state.server.prefixchars)
            {
                import dialect.common : setMode;
                import std.conv : to;

                immutable modestring = (*modechar).to!string;
                (*channel).setMode(modestring, event.target.nickname, plugin.state.server);
            }
            else
            {
                //logger.warning("Invalid modesign in RPL_WHOREPLY: ", modesign);
            }
        }
    }

    if (event.target.nickname == plugin.state.client.nickname) return;

    // In case no mode was applied
    channel.users[event.target.nickname] = true;
}


// onChannelAwarenessNamesReply
/++
    Adds users as being part of a channel upon receiving the reply from the
    request for a list of all the participants.

    On some servers this does not include information about the users, only
    their nickname and their channel mode (e.g. `@` for operator), but other
    servers express the users in the full `user!ident@address` form.
 +/
void onChannelAwarenessNamesReply(IRCPlugin plugin, const ref IRCEvent event)
{
    import dialect.common : stripModesign;
    import lu.string : contains;
    import std.algorithm.iteration : splitter;
    import std.string : representation;

    if (!event.content.length) return;

    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    auto names = event.content.splitter(' ');

    foreach (immutable userstring; names)
    {
        string slice = userstring;
        string nickname;

        if (userstring.contains('!'))// && userstring.contains('@'))  // No need to check both
        {
            import lu.string : nom;
            // SpotChat-like, names are in full nick!ident@address form
            nickname = slice.nom('!');
        }
        else
        {
            // Freenode-like, only a nickname with possible @%+ prefix
            nickname = userstring;
        }

        string modesigns;  // mutable
        nickname = nickname.stripModesign(plugin.state.server, modesigns);

        // Register operators, half-ops, voiced etc
        // Can be more than one if multi-prefix capability is enabled
        // Server-sent string, can assume ASCII (@,%,+...) and go char by char
        foreach (immutable modesign; modesigns.representation)
        {
            if (const modechar = modesign in plugin.state.server.prefixchars)
            {
                import dialect.common : setMode;
                import std.conv : to;

                immutable modestring = (*modechar).to!string;
                (*channel).setMode(modestring, nickname, plugin.state.server);
            }
            else
            {
                //logger.warning("Invalid modesign in RPL_NAMREPLY: ", modesign);
            }
        }

        channel.users[nickname] = true;
    }
}


// onChannelAwarenessModeLists
/++
    Adds users of a certain "list" mode to a tracked channel's list of modes
    (banlist, exceptlist, invitelist, etc).
 +/
void onChannelAwarenessModeLists(IRCPlugin plugin, const ref IRCEvent event)
{
    import dialect.common : setMode;
    import std.conv : to;

    // :kornbluth.freenode.net 367 kameloso #flerrp huerofi!*@* zorael!~NaN@2001:41d0:2:80b4:: 1513899527
    // :kornbluth.freenode.net 367 kameloso #flerrp harbl!harbl@snarbl.com zorael!~NaN@2001:41d0:2:80b4:: 1513899521
    // :niven.freenode.net 346 kameloso^ #flerrp asdf!fdas@asdf.net zorael!~NaN@2001:41d0:2:80b4:: 1514405089
    // :niven.freenode.net 728 kameloso^ #flerrp q qqqq!*@asdf.net zorael!~NaN@2001:41d0:2:80b4:: 1514405101

    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    with (IRCEvent.Type)
    {
        string modestring;

        switch (event.type)
        {
        case RPL_BANLIST:
            modestring = "b";
            break;

        case RPL_EXCEPTLIST:
            modestring = (plugin.state.server.exceptsChar == 'e') ?
                "e" : plugin.state.server.exceptsChar.to!string;
            break;

        case RPL_INVITELIST:
            modestring = (plugin.state.server.invexChar == 'I') ?
                "I" : plugin.state.server.invexChar.to!string;
            break;

        case RPL_REOPLIST:
            modestring = "R";
            break;

        case RPL_QUIETLIST:
            modestring = "q";
            break;

        default:
            assert(0, "Unexpected IRC event type annotation on " ~
                "`onChannelAwarenessModeListMixin`");
        }

        (*channel).setMode(modestring, event.content, plugin.state.server);
    }
}


// onChannelAwarenessChannelModeIs
/++
    Adds the modes of a channel to a tracked channel's mode list.
 +/
void onChannelAwarenessChannelModeIs(IRCPlugin plugin, const ref IRCEvent event)
{
    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    import dialect.common : setMode;
    // :niven.freenode.net 324 kameloso^ ##linux +CLPcnprtf ##linux-overflow
    (*channel).setMode(event.aux[0], event.content, plugin.state.server);
}


// TwitchAwareness
/++
    Implements scraping of Twitch message events for user details in a module.

    Twitch doesn't always enumerate channel participants upon joining a channel.
    It seems to mostly be done on larger channels, and only rarely when the
    channel is small.

    There is a chance of a user leak, if parting users are not broadcast. As
    such we mark when the user was last seen in the
    [dialect.defs.IRCUser.updated|IRCUser.updated] member, which opens up the possibility
    of pruning the plugin's [kameloso.plugins.common.core.IRCPluginState.users|IRCPluginState.users]
    array of old entries.

    Twitch awareness needs channel awareness, or it is meaningless.

    Params:
        channelPolicy = What [kameloso.plugins.common.core.ChannelPolicy|ChannelPolicy]
            to apply to enwrapped event handlers.
        debug_ = Whether or not to include debugging output.
        module_ = String name of the mixing-in module; generally leave as-is.

    See_Also:
        [kameloso.plugins.common.awareness.MinimalAuthentication|MinimalAuthentication]
        [kameloso.plugins.common.awareness.UserAwareness|UserAwareness]
        [kameloso.plugins.common.awareness.ChannelAwareness|ChannelAwareness]
 +/
version(TwitchSupport)
mixin template TwitchAwareness(
    ChannelPolicy channelPolicy = ChannelPolicy.home,
    Flag!"debug_" debug_ = No.debug_,
    string module_ = __MODULE__)
{
    private import dialect.defs : IRCEvent;
    private static import kameloso.plugins.common.awareness;

    /++
        Flag denoting that [kameloso.plugins.common.awareness.TwitchAwareness|TwitchAwareness]
        has been mixed in.
     +/
    package enum hasTwitchAwareness = true;

    static if (!__traits(compiles, { alias _ = .hasChannelAwareness; }))
    {
        import std.format : format;

        enum pattern = "`%s` is missing a `ChannelAwareness` mixin " ~
            "(needed for `TwitchAwareness`)";
        enum message = pattern.format(module_);
        static assert(0, message);
    }

    // onTwitchAwarenessSenderCarryingEventMixin
    /++
        Proxies to
        [kameloso.plugins.common.awareness.onTwitchAwarenessSenderCarryingEvent|onTwitchAwarenessSenderCarryingEvent].

        See_Also:
            [kameloso.plugins.common.awareness.onTwitchAwarenessSenderCarryingEvent|onTwitchAwarenessSenderCarryingEvent]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.CHAN)  // Catch these as we don't index people by WHO on Twitch
        .onEvent(IRCEvent.Type.JOIN)
        .onEvent(IRCEvent.Type.SELFJOIN)
        .onEvent(IRCEvent.Type.PART)
        .onEvent(IRCEvent.Type.EMOTE) // As above
        .onEvent(IRCEvent.Type.TWITCH_SUB)
        .onEvent(IRCEvent.Type.TWITCH_CHEER)
        .onEvent(IRCEvent.Type.TWITCH_SUBGIFT)
        .onEvent(IRCEvent.Type.TWITCH_BITSBADGETIER)
        .onEvent(IRCEvent.Type.TWITCH_RAID)
        .onEvent(IRCEvent.Type.TWITCH_UNRAID)
        .onEvent(IRCEvent.Type.TWITCH_RITUAL)
        .onEvent(IRCEvent.Type.TWITCH_REWARDGIFT)
        .onEvent(IRCEvent.Type.TWITCH_GIFTCHAIN)
        .onEvent(IRCEvent.Type.TWITCH_SUBUPGRADE)
        .onEvent(IRCEvent.Type.TWITCH_CHARITY)
        .onEvent(IRCEvent.Type.TWITCH_BULKGIFT)
        .onEvent(IRCEvent.Type.TWITCH_EXTENDSUB)
        .onEvent(IRCEvent.Type.TWITCH_GIFTRECEIVED)
        .onEvent(IRCEvent.Type.TWITCH_PAYFORWARD)
        .onEvent(IRCEvent.Type.TWITCH_CROWDCHANT)
        .onEvent(IRCEvent.Type.TWITCH_ANNOUNCEMENT)
        .onEvent(IRCEvent.Type.TWITCH_DIRECTCHEER)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onTwitchAwarenessSenderCarryingEventMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onTwitchAwarenessSenderCarryingEvent(plugin, event);
    }

    // onTwitchAwarenessTargetCarryingEventMixin
    /++
        Catch targets from normal Twitch events.

        This has to be done on certain Twitch channels whose participants are
        not enumerated upon joining it, nor joins or parts announced. By
        listening for any message with targets and catching that user that way
        we ensure we do our best to scrape the channels.

        See_Also:
            [kameloso.plugins.common.awareness.onTwitchAwarenessSenderCarryingEvent|onTwitchAwarenessSenderCarryingEvent]
     +/
    @(IRCEventHandler()
        .onEvent(IRCEvent.Type.TWITCH_BAN)
        .onEvent(IRCEvent.Type.TWITCH_SUBGIFT)
        .onEvent(IRCEvent.Type.TWITCH_REWARDGIFT)
        .onEvent(IRCEvent.Type.TWITCH_TIMEOUT)
        .onEvent(IRCEvent.Type.TWITCH_GIFTCHAIN)
        .onEvent(IRCEvent.Type.TWITCH_GIFTRECEIVED)
        .onEvent(IRCEvent.Type.TWITCH_PAYFORWARD)
        .onEvent(IRCEvent.Type.CLEARMSG)
        .onEvent(IRCEvent.Type.GLOBALUSERSTATE)
        .channelPolicy(channelPolicy)
        .when(Timing.early)
        .chainable(true)
    )
    void onTwitchAwarenessTargetCarryingEventMixin(IRCPlugin plugin, const ref IRCEvent event) @system
    {
        return kameloso.plugins.common.awareness.onTwitchAwarenessTargetCarryingEvent(plugin, event);
    }
}


// onTwitchAwarenessSenderCarryingEvent
/++
    Catch senders from normal Twitch events.

    This has to be done on certain Twitch channels whose participants are
    not enumerated upon joining it, nor joins or parts announced. By
    listening for any message and catching the user that way we ensure we
    do our best to scrape the channels.

    See_Also:
        [kameloso.plugins.common.awareness.onTwitchAwarenessTargetCarryingEvent|onTwitchAwarenessTargetCarryingEvent]
 +/
version(TwitchSupport)
void onTwitchAwarenessSenderCarryingEvent(IRCPlugin plugin, const ref IRCEvent event)
{
    import kameloso.plugins.common.misc : catchUser;

    if (plugin.state.server.daemon != IRCServer.Daemon.twitch) return;

    if (!event.sender.nickname) return;

    // Move the catchUser call here to populate the users array with users in guest channels
    //catchUser(plugin, event.sender);

    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    if (event.sender.nickname !in channel.users)
    {
        channel.users[event.sender.nickname] = true;
    }

    catchUser(plugin, event.sender);  // <-- this one
}


// onTwitchAwarenessTargetCarryingEvent
/++
    Catch targets from normal Twitch events.

    This has to be done on certain Twitch channels whose participants are
    not enumerated upon joining it, nor joins or parts announced. By
    listening for any message with targets and catching that user that way
    we ensure we do our best to scrape the channels.

    See_Also:
        [kameloso.plugins.common.awareness.onTwitchAwarenessSenderCarryingEvent|onTwitchAwarenessSenderCarryingEvent]
 +/
version(TwitchSupport)
void onTwitchAwarenessTargetCarryingEvent(IRCPlugin plugin, const ref IRCEvent event)
{
    import kameloso.plugins.common.misc : catchUser;

    if (plugin.state.server.daemon != IRCServer.Daemon.twitch) return;

    if (!event.target.nickname) return;

    // Move the catchUser call here to populate the users array with users in guest channels
    //catchUser(plugin, event.target);

    auto channel = event.channel in plugin.state.channels;
    if (!channel) return;

    if (event.target.nickname !in channel.users)
    {
        channel.users[event.target.nickname] = true;
    }

    catchUser(plugin, event.target);   // <-- this one
}


version(TwitchSupport) {}
else
/++
    No-op mixin of version `!TwitchSupport` [kameloso.plugins.common.awareness.TwitchAwareness|TwitchAwareness].
 +/
mixin template TwitchAwareness(
    ChannelPolicy channelPolicy = ChannelPolicy.home,
    Flag!"debug_" debug_ = No.debug_,
    string module_ = __MODULE__)
{
    /++
        Flag denoting that [kameloso.plugins.common.awareness.TwitchAwareness|TwitchAwareness]
        has been mixed in.
     +/
    package enum hasTwitchAwareness = true;

    static if (!__traits(compiles, { alias _ = .hasChannelAwareness; }))
    {
        import std.format : format;

        enum pattern = "`%s` is missing a `ChannelAwareness` mixin " ~
            "(needed for `TwitchAwareness`)";
        enum message = pattern.format(module_);
        static assert(0, message);
    }
}