/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  InspIRCd: (C) 2002-2011 InspIRCd Development Team
 * See: http://wiki.inspircd.org/Credits
 *
 * This program is free but copyrighted software; see
 *            the file COPYING for details.
 *
 * ---------------------------------------------------
 */

#include "inspircd.h"
#include "protocol.h"
#include "account.h"
#include "opflags.h"
#include "u_listmode.h"

/* $ModDesc: Provides support for the +w channel mode, autoop list */

static dynamic_reference<AccountDBProvider> db("accountdb");

/** Handles +n user mode
 */
class NoAutoopMode : public SimpleUserModeHandler
{
 public:
	NoAutoopMode(Module* Creator) : SimpleUserModeHandler(Creator, "noautoop", 'n') { }
};

/** Handles +w channel mode
 */
class AutoOpList : public ListModeBase
{
 public:
	AutoOpList(Module* Creator) : ListModeBase(Creator, "autoop", 'w', "End of Channel Access List", 910, 911, true)
	{
		levelrequired = OP_VALUE;
		fixed_letter = false;
		tidy = false;
	}

	void AccessCheck(ModePermissionData& perm)
	{
		std::string::size_type pos = perm.mc.value.find(':');
		if (pos == 0 || pos == std::string::npos)
		{
			if (perm.mc.adding)
				perm.result = MOD_RES_DENY;
			return;
		}
		unsigned int mylevel = perm.chan->GetAccessRank(perm.source);
		irc::commasepstream modes(perm.mc.value.substr(0, pos));
		std::string mid;
		while (modes.GetToken(mid))
		{
			ModeHandler* mh = mid.length() == 1 ?
				ServerInstance->Modes->FindMode(mid[0], MODETYPE_CHANNEL) :
				ServerInstance->Modes->FindMode(mid);

			if (perm.mc.adding && mh && mh->GetLevelRequired() > mylevel)
			{
				perm.ErrorNumeric(482, "%s :You must be able to set mode '%s' to include it in an autoop",
					perm.chan->name.c_str(), mid.c_str());
				perm.result = MOD_RES_DENY;
			}
		}
	}
};

class ModuleAutoOp : public Module
{
	AutoOpList mh;
	NoAutoopMode mh2;
	dynamic_reference<OpFlagProvider> opflags;
	bool checkonlogin, checkonhostchange, allow_selfup;

public:
	ModuleAutoOp() : mh(this), mh2(this), opflags("opflags")
	{
	}

	void init()
	{
		mh.init();
		ServerInstance->Modules->AddService(mh);
		ServerInstance->Modules->AddService(mh2);

		Implementation list[] = { I_OnPostJoin, I_OnEvent, I_OnChangeHost, I_OnPermissionCheck, I_OnGarbageCollect };
		ServerInstance->Modules->Attach(list, this, sizeof(list)/sizeof(Implementation));
	}

	void PrepareAutoop(Membership* memb, irc::modestacker& ms, std::set<std::string>& flags)
	{
		modelist* list = mh.extItem.get(memb->chan);
		if (!list)
			return;
		for (modelist::const_iterator it = list->begin(); it != list->end(); ++it)
		{
			std::string::size_type colon = it->mask.find(':');
			if (colon == std::string::npos)
				continue;
			if (!memb->chan->CheckBan(memb->user, it->mask.substr(colon+1)))
				continue;
			irc::commasepstream modes(it->mask.substr(0, colon));
			std::string mflag;
			while (modes.GetToken(mflag))
			{
				ModeHandler* given = mflag.length() == 1 ?
					ServerInstance->Modes->FindMode(mflag[0], MODETYPE_CHANNEL) :
					ServerInstance->Modes->FindMode(mflag);
				if (given && given->GetPrefixRank())
					ms.push(irc::modechange(given->id, memb->user->nick, true));
				else if (!given)
				{
					// it's a flag
					flags.insert(mflag);
				}
			}
		}
	}

	void DoAutoop(Membership* memb)
	{
		irc::modestacker ms;
		std::set<std::string> flags;
		PrepareAutoop(memb, ms, flags);
		if (!ms.empty())
		{
			User* src = ServerInstance->Config->CycleHostsFromUser ? memb->user : ServerInstance->FakeClient;
			ServerInstance->Modes->Process(src, memb->chan, ms, false, true);
			ServerInstance->Modes->Send(src, memb->chan, ms);
			ServerInstance->PI->SendMode(src, memb->chan, ms);
		}
		if (opflags && !flags.empty())
		{
			std::string message = ServerInstance->Config->ServerName + " set " + memb->user->nick + " opflags to " + opflags->SetFlags(memb, flags, true);
			memb->chan->WriteChannelWithServ(ServerInstance->Config->ServerName.c_str(), "NOTICE %s :%s", memb->chan->name.c_str(), message.c_str());
			ServerInstance->PI->SendChannelNotice(memb->chan, 0, message);
		}
	}


	void OnPostJoin(Membership* memb)
	{
		if (!IS_LOCAL(memb->user) || memb->user->IsModeSet('n'))
			return;
		DoAutoop(memb);
	}

	void OnEvent(Event& event)
	{
		if(checkonlogin && event.id == "account_login"){
			AccountEvent& acct_event = static_cast<AccountEvent&>(event);
			if(!IS_LOCAL(acct_event.user) || acct_event.user->IsModeSet('n')) return;
			for (UCListIter v = acct_event.user->chans.begin(); v != acct_event.user->chans.end(); ++v)
				DoAutoop(&*v);
		}
	}

	void OnChangeHost(User* u, const std::string&)
	{
		if(checkonhostchange && !u->IsModeSet('n'))
			for (UCListIter v = u->chans.begin(); v != u->chans.end(); ++v)
				DoAutoop(&*v);
	}

	void OnPermissionCheck(PermissionData& perm)
	{
		if (!allow_selfup || !perm.chan || perm.user != perm.source ||
				perm.result != MOD_RES_PASSTHRU)
			return;
		Membership* memb = perm.chan->GetUser(perm.user);
		if (!memb)
			return;
		irc::modestacker ms;
		std::set<std::string> flags;
		PrepareAutoop(memb, ms, flags);

		if (perm.name.substr(0,5) == "mode/")
		{
			ModePermissionData& mpd = static_cast<ModePermissionData&>(perm);
			if (!mpd.mc.adding)
				return;
			for(std::vector<irc::modechange>::const_iterator i = ms.sequence.begin(); i != ms.sequence.end(); ++i)
			{
				if (i->mode == mpd.mc.mode)
				{
					mpd.result = MOD_RES_ALLOW;
					return;
				}
			}
		}
		else if (perm.name == "opflags")
		{
			OpFlagPermissionData& opd = static_cast<OpFlagPermissionData&>(perm);
			irc::commasepstream deltaflags(opd.delta);
			std::string flag;
			while (deltaflags.GetToken(flag))
			{
				if (flag[0] == '-' || flag[0] == '=')
					return;
				if (flag[0] == '+')
					flag = flag.substr(1);
				if (flags.find(flag) == flags.end())
					return;
			}
			// all flags mentioned in this change are in the autoop list
			opd.result = MOD_RES_ALLOW;
		}
	}

	void ReadConfig(ConfigReadStatus&)
	{
		mh.DoRehash();
		ConfigTag* tag = ServerInstance->Config->GetTag("autoop");
		allow_selfup = tag->getBool("selfop", true);
		checkonlogin = tag->getBool("checkonlogin", true);
		checkonhostchange = tag->getBool("checkonhostchange", true);
	}

	void Prioritize()
	{
		ServerInstance->Modules->SetPriority(this, I_OnGarbageCollect, PRIORITY_AFTER, ServerInstance->Modules->Find("m_account_register.so"));
	}

	void OnGarbageCollect ()
	{
		if(!db) return;
		irc::modestacker ms;
		for (chan_hash::const_iterator iter = ServerInstance->chanlist->begin(); iter != ServerInstance->chanlist->end(); ++iter)
		{
			modelist* list = mh.extItem.get(iter->second);
			if (!list)
				continue;
			ms.sequence.clear();
			for (modelist::const_iterator it = list->begin(); it != list->end(); ++it)
			{
				std::string::size_type colon = it->mask.find_first_of(':');
				if (colon == std::string::npos)
					continue;
				std::string mask = it->mask.substr(colon + 1);
				if(mask.length() < 2 || mask[0] != 'r' || mask[1] != ':')
					continue;
				if(!db->GetAccount(mask.substr(2), false))
					ms.sequence.push_back(irc::modechange(mh.id, it->mask, false));
			}
			if(!ms.sequence.empty())
				ServerInstance->SendMode(ServerInstance->FakeClient, iter->second, ms, true);
		}
	}

	Version GetVersion()
	{
		return Version("Provides support for the +w channel mode", VF_VENDOR);
	}
};

MODULE_INIT(ModuleAutoOp)