znc-idlerpg/idlerpg.cpp

#include <znc/Chan.h>
#include <znc/IRCNetwork.h>

using std::map;

class CIdleRPGMod;

#define IDLERPG_JOIN_LOGIN_WAIT_TIME 10

class CIdleRPGChannel {
  public:
    CIdleRPGChannel() {}
    CIdleRPGChannel(const CString& sLine) { FromString(sLine); }
    virtual ~CIdleRPGChannel() {}

    const CString& GetChannel() const { return m_Channel; }
    const CString& GetBotnick() const { return m_Botnick; }
    const CString& GetUsername() const { return m_Username; }
    const CString& GetPassword() const { return m_Password; }

    bool FromString(const CString& sLine) {
        m_Channel = sLine.Token(0).AsLower();
        m_Botnick = sLine.Token(1);
        m_Username = sLine.Token(2);
        m_Password = sLine.Token(3);

        return !m_Channel.empty() && !m_Botnick.empty() &&
               !m_Username.empty() && !m_Password.empty();
    }

    CString ToString() const {
        return GetChannel() + " " + GetBotnick() + " " + GetUsername() + " " +
               GetPassword();
    }

  private:
  protected:
    CString m_Channel;
    CString m_Botnick;
    CString m_Username;
    CString m_Password;
};

class CIdleRPGModTimer : public CTimer {
  public:
    CIdleRPGModTimer(CModule* pModule, CIdleRPGChannel* sChannel,
                     unsigned int uInterval, unsigned int uCycles,
                     const CString& sLabel, const CString& sDescription)
        : CTimer(pModule, uInterval, uCycles, sLabel, sDescription) {
        pChannel = sChannel;
    }

    ~CIdleRPGModTimer() override {}

  protected:
    void RunJob() override;

  private:
    CIdleRPGChannel* pChannel;
};

class CIdleRPGMod : public CModule {
  public:
    MODCONSTRUCTOR(CIdleRPGMod) {
        AddHelpCommand();

        AddCommand("Add", t_d("<#channel> <botnick> <username> <password>"),
                   t_d("Adds a new channel or updates a channel"),
                   [=](const CString& sLine) { CommandAdd(sLine); });
        AddCommand("Del", t_d("<#channel>"), t_d("Removes a channel"),
                   [=](const CString& sLine) { CommandDel(sLine); });
        AddCommand("Clear", "", t_d("Clears all current settings"),
                   [=](const CString& sLine) { CommandClear(); });
        AddCommand("List", "", t_d("Displays current settings"),
                   [=](const CString& sLine) { CommandList(); });
        AddCommand("Login", t_d("[<#channel>]"),
                   t_d("Manually triggers login now (either for specific "
                       "channel or all channels)"),
                   [=](const CString& sLine) { CommandLogin(sLine); });
    }

    ~CIdleRPGMod() override {}

    bool OnLoad(const CString& sArgs, CString& sMessage) override {
        // Load current channels
        for (MCString::iterator it = BeginNV(); it != EndNV(); ++it) {
            const CString& sLine = it->second;
            CIdleRPGChannel* pChannel = new CIdleRPGChannel;

            if (!pChannel->FromString(sLine) ||
                FindChannel(pChannel->GetChannel())) {
                delete pChannel;
            } else {
                m_Channels[pChannel->GetChannel()] = pChannel;
            }
        }

        return true;
    }

    CIdleRPGChannel* FindChannel(const CString& sChannel) {
        map<CString, CIdleRPGChannel*>::iterator it = m_Channels.find(sChannel);

        return (it != m_Channels.end()) ? it->second : nullptr;
    }

    void CommandList() {
        if (m_Channels.empty()) {
            PutModule(t_s("No channels setup yet. Try: help add"));
            return;
        }

        CTable Table;
        Table.AddColumn(t_s("Channel"));
        Table.AddColumn(t_s("Botnick"));
        Table.AddColumn(t_s("Username"));
        Table.AddColumn(t_s("Password"));

        for (const auto& it : m_Channels) {
            Table.AddRow();
            Table.SetCell(t_s("Channel"), it.second->GetChannel());
            Table.SetCell(t_s("Botnick"), it.second->GetBotnick());
            Table.SetCell(t_s("Username"), it.second->GetUsername());
            Table.SetCell(t_s("Password"), it.second->GetPassword());
        }

        PutModule(Table);
    }

    void CommandAdd(const CString& sLine) {
        if (sLine.Token(1).empty()) {
            PutModule(
                t_s("Usage: Add <#channel> <botnick> <username> <password>"));
            return;
        }

        CString sChannel = sLine.Token(1).AsLower();
        CString sBotnick = sLine.Token(2);
        CString sUsername = sLine.Token(3);
        CString sPassword = sLine.Token(4);

        if (sChannel.empty()) {
            PutModule("Channel not supplied");
            return;
        }
        if (sBotnick.empty()) {
            PutModule("Botnick not supplied");
            return;
        }
        if (sUsername.empty()) {
            PutModule("Username not supplied");
            return;
        }
        if (sPassword.empty()) {
            PutModule("Password not supplied");
            return;
        }

        CIdleRPGChannel* pChannel = new CIdleRPGChannel();
        pChannel->FromString(sChannel + " " + sBotnick + " " + sUsername + " " +
                             sPassword);
        m_Channels[pChannel->GetChannel()] = pChannel;
        SetNV(pChannel->GetChannel(), pChannel->ToString());

        PutModule(
            t_f("Saved settings for channel {1}")(pChannel->GetChannel()));
    }

    void CommandDel(const CString& sLine) {
        if (sLine.Token(1).empty()) {
            PutModule(t_s("Usage: Del <#channel>"));
            return;
        }
        CString sChannel = sLine.Token(1).AsLower();

        map<CString, CIdleRPGChannel*>::iterator it = m_Channels.find(sChannel);

        if (it == m_Channels.end()) {
            PutModule(t_f("Channel {1} not found")(sChannel));
            return;
        }

        delete it->second;
        m_Channels.erase(it);
        DelNV(sChannel);
        PutModule(t_f("Channel {1} removed")(sChannel));
    }

    void CommandLogin(const CString& sLine) {
        CString sChannel = sLine.Token(1).AsLower();
        if (!sChannel.empty()) {
            CIdleRPGChannel* fChannel = FindChannel(sChannel);
            if (!fChannel) {
                PutModule(t_f("Invalid channel {1}")(sChannel));
                return;
            }

            Login(fChannel);
            return;
        }

        // Go through all channels and login
        for (const auto& it : m_Channels) {
            Login(it.second);
        }
    }

    void CommandClear() {
        ClearNV();
        m_Channels.clear();
        PutModule(t_s("All settings cleared!"));
    }

    void QueueLogin(CIdleRPGChannel* sChan) {
        RemTimer("idlerpg_login_timer_" + sChan->GetChannel());
        AddTimer(
            new CIdleRPGModTimer(this, sChan, IDLERPG_JOIN_LOGIN_WAIT_TIME, 1,
                                 "idlerpg_login_timer_" + sChan->GetChannel(),
                                 "Tries login to IdleRPG bot"));
    }

    void Login(CIdleRPGChannel* sChan) {
        // Valid channel?
        CChan* pChan = this->GetNetwork()->FindChan(sChan->GetChannel());
        if (!pChan) {
            PutModule(t_f("Error logging in: Invalid channel [{1}]")(
                sChan->GetChannel()));
            return;
        }

        // Botnick on channel?
        CNick* pBot = pChan->FindNick(sChan->GetBotnick());
        if (!pBot) {
            PutModule(
                t_f("Error logging in: Bot [{1}] not found in channel [{2}]")(
                    sChan->GetBotnick(), sChan->GetChannel()));
            return;
        }

        // Bot has op?
        if (!pBot->HasPerm(CChan::Op)) {
            PutModule(t_f(
                "Error logging in: Bot [{1}] not operator in in channel [{2}]")(
                sChan->GetBotnick(), sChan->GetChannel()));
            return;
        }

        PutIRC("PRIVMSG " + sChan->GetBotnick() + " :login " +
               sChan->GetUsername() + " " + sChan->GetPassword());
        PutModule(t_s("Logging you in with " + sChan->GetBotnick() + " on " +
                      sChan->GetChannel()));
    }

    void OnJoin(const CNick& Nick, CChan& Channel) override {
        // Setup done?
        if (m_Channels.empty()) {
            return;
        }

        // Correct channel?
        CIdleRPGChannel* fChannel = FindChannel(Channel.GetName().AsLower());
        if (!fChannel) {
            return;
        }

        // Either Bot or user joins
        if (Nick.GetNick() != fChannel->GetBotnick() &&
            !GetNetwork()->GetCurNick().Equals(Nick.GetNick())) {
            return;
        }

        QueueLogin(fChannel);
    }

  private:
    map<CString, CIdleRPGChannel*> m_Channels;
};

void CIdleRPGModTimer::RunJob() {
    ((CIdleRPGMod*)GetModule())->Login(pChannel);
}

template <>
void TModInfo<CIdleRPGMod>(CModInfo& Info) {
    Info.AddType(CModInfo::NetworkModule);
    Info.SetWikiPage("idlerpg");
}

NETWORKMODULEDEFS(
    CIdleRPGMod,
    t_s("Automatically handles your login to IdleRPG games/channels"))