#!/usr/bin/env python3
"""
The core bot class for Fulvia.
"""
import os
import sys
import time
import functools
import threading
import traceback
from datetime import datetime

from twisted.internet import protocol
from twisted.words.protocols import irc

import db
import tools
import loader
from trigger import Trigger

class Fulvia(irc.IRCClient):
	def __init__(self, config):
		self.config = config
		"""The bot's config, loaded from file."""

		self.nickname = config.core.nickname
		self.nick = config.core.nickname
		"""The bot's current nickname."""

		self.realname = config.core.realname
		"""The bot's 'real name', used in whois."""

		self.username = config.core.username
		"""The bot's username ident used for logging into the server."""

		self.host = ""
		"""The bot's host, virtual or otherwise. To be filled in later."""

		self.prefix = config.core.prefix
		"""The command prefix the bot watches for."""

		self.static = os.path.join(config.homedir, "static")
		os.makedirs(self.static, exist_ok=True)
		"""The path to the bot's static file directory."""

		self.log_path = os.path.join(config.homedir, "logs")
		os.makedirs(self.static, exist_ok=True)
		"""The path to the bot's log files."""

		self._log_dump = tools.FulviaMemoryDefault(list)
		"""
		Internal thread-safe dictionary containing log dumps yet to be
		written.
		"""

		self._last_log_dump = 0
		"""The last time logs were dumped."""

		self.channels = tools.FulviaMemory()
		"""
		A dictionary of all channels the bot is currently in and the users
		in them.
		"""

		self.users = tools.FulviaMemory()
		"""A dictionary of all users the bot is aware of."""

		self.memory = tools.FulviaMemory()
		"""
		A thread-safe general purpose dictionary to be used by whatever
		modules need it.
		"""

		self.db = db.FulviaDB(self.config)
		"""
		A class with some basic interactions for the bot's sqlite3 databse.
		"""

		self._callables = {}
		"""
		A dictionary containing all callable functions loaded from 
		modules. Keys are the functions name.
		"""

		self._hooks = []
		"""
		A list containing all function names to be hooked with every message
		received.
		"""

		self.commands = {}
		"""
		A dictionary containing all commands to look for and the name
		of the function they call.
		"""

		self._times = {}
		"""
		A dictionary full of times when certain functions were called for
		use with the @rate decorator. Keys are function names.
		"""

		self.url_callbacks = {}
		"""
		A dictionary of URL callbacks to allow other modules interact with
		the URL module.
		"""

		self._disabled_modules = self.config.core.disabled_modules.split(",")
		"""These modules will NOT be loaded when load_modules() is called."""

		self.load_modules()


	def load_modules(self):
		"""
		Find and load all of our modules.
		"""
		print(f"Loading modules...")
		self._callables = {}
		self._hooks = []
		self.commands = {}
		self._times = {}
		self.url_callbacks = {}
		# ensure they're empty

		modules = loader.find_modules(self.config.homedir)
		loaded = 0
		failed = 0
		for name, path in modules.items():
			try:
				if name in self._disabled_modules:
					continue
				loader.load_module(self, path)
				loaded += 1
			except Exception as e:
				print(f"{name} failed to load.")
				print(e)
				traceback.print_exc()
				failed += 1
				continue
		print(f"Registered {loaded} modules,")
		print(f"{failed} modules failed to load")


	def register_callable(self, func):
		"""
		Registers all callable functions loaded from modules into one
		convenient table.
		"""
		if hasattr(func, 'commands'):
			self._callables[func.__name__] = func
			for cmd in func.commands:
				self.commands[cmd] = tools.Command(cmd)
				self.commands[cmd]._func_name = func.__name__
				self.commands[cmd].priv = func.priv
				self.commands[cmd].doc = func._docs
				if cmd in func.aliases:
					self.commands[cmd].canonical = False
				aliases = [a for a in func.commands if a != cmd]
				self.commands[cmd].aliases = aliases

		if func.hook:
			self._callables[func.__name__] = func
			self._hooks.append(func.__name__)

		if func.rate or func.channel_rate or func.global_rate:
			self._times[func.__name__] = {}

		if hasattr(func, 'url_callback'):
			for url in func.url_callback:
				self.url_callbacks[url] = func


	def unregister_callable(self, func):
		"""
		Removes the provided function object from the internal list of
		module functions.
		"""
		if not callable(func) or not loader.is_triggerable(func):
			return

		if hasattr(func, 'commands'):
			self._callables.pop(func.__name__)
			for command in func.commands:
				self.commands.pop(command)

		if func.hook:
			self._callables.pop(func.__name__)
			self._hooks.remove(func.__name__)

		if func.rate or func.channel_rate or func.global_rate:
			self._times.pop(func.__name__)

		if hasattr(func, 'url_callback'):
			for url in func.url_callback:
				self.url_callbacks.pop(url)


	def stillConnected(self):
		"""Returns true if the bot is still connected to the server."""
		if self._heartbeat:
			return True
		else:
			return False


	def call(self, func, bot, trigger):
		"""
		A wrapper for calling module functions so that we can have nicer
		error handling.
		"""
		try:
			func(bot, trigger)
		except Exception as e:
			msg = type(e).__name__ + ": " + str(e)
			self.msg(trigger.channel, msg)
			traceback.print_exc()


	def log(self, channel, text):
		"""
		Logs text to file. Logging structure is
		{self.log_path}/{self.server}/{channel}/{date}.log

		Only permits log dumping once per second.
		"""
		# TODO: use time module instead of datetime
		t = datetime.fromtimestamp(time.time())
		timestamp = t.strftime(self.config.core.default_time_format)
		self._log_dump[channel].append(timestamp + " " + text)

		if time.time() - self._last_log_dump > 1:
			for ch in self._log_dump.keys():
				fname = t.strftime("%Y-%m-%d") + ".log"
				path = os.path.join(self.log_path, self.hostname, ch)
				os.makedirs(path, exist_ok=True)
				with open(os.path.join(path, fname), "a+") as file:
					file.write("\n".join(self._log_dump[ch]) + "\n")

			del(self._log_dump)
			self._log_dump = tools.FulviaMemoryDefault(list)


	## Actions involving the bot directly.
	## These will get called automatically.

	def privmsg(self, user, channel, message):
		"""
		Called when the bot receives a PRIVMSG, which can come from channels
		or users alike.
		"""
		nick = user.partition("!")[0].partition("@")[0]
		if channel.startswith("#"):
			opSym = tools.getOpSym(self.channels[channel].privileges[nick])
		else:
			opSym = ""
			channel = nick
		line = "<" + opSym + nick + ">" + " " + message
		self.log(channel, line)

		func_names = []
		if message.startswith(self.prefix) and message != self.prefix:
			command, _, _ = message.partition(" ")
			command = command.replace(self.prefix, "", 1)
			cmd = self.commands.get(command)
			if not cmd:
				return
			func_names.append(cmd._func_name)

		func_names += self._hooks

		for func_name in func_names:
			func = self._callables[func_name]
			trigger = Trigger(user, channel, message, "PRIVMSG", self.config)
			bot = FulviaWrapper(self, trigger)

			if func.rate:
				t = self._times[func_name].get(trigger.nick, 0)
				if time.time() - t < func.rate and not trigger.admin:
					return
				self._times[func_name][trigger.nick] = time.time()

			if func.channel_rate:
				t = self._times[func_name].get(trigger.channel, 0)
				if time.time() - t < func.channel_rate and not trigger.admin:
					return
				self._times[func_name][trigger.channel] = time.time()

			if func.global_rate:
				t = self._times[func_name].get("global", 0)
				if time.time() - t < func.channel_rate and not trigger.admin:
					return
				self._times[func_name]["global"] = time.time()

			if func.thread == True:
				t = threading.Thread(target=self.call,args=(func, bot, trigger))
				t.start()
			else:
				self.call(func, bot, trigger)


	def joined(self, channel):
		"""Called when the bot joins a new channel."""
		line = "-!- " + self.nickname + " " + "[" + self.username + "@"
		line += self.host + "] has joined " + channel
		self.log(channel, line)

		print(f"Joined {channel}")
		if channel not in self.channels:
			self.channels[channel] = tools.Channel(channel)


	def left(self, channel, reason=""):
		"""Called when the bot leaves a channel."""
		line = "-!- " + self.nickname + " " + "[" + self.username + "@"
		line += self.host + "] has left " + channel + " [" + reason + "]"
		self.log(channel, line)

		print(f"Parted {channel}")
		self.channels.pop(channel)


	def noticed(self, user, channel, message):
		"""Called when the bot receives a NOTICE from a user or channel."""
		# TODO: something?
		pass


	def modeChanged(self, user, channel, add_mode, modes, args):
		"""Called when users or channel's modes are changed."""
		line = "-!- mode/" + channel + " ["
		if add_mode:
			line += "+"
		else:
			line += "-"
		line += modes
		if any(args):
			line += " " + " ".join(args)
		line += "] by " + user.partition("!")[0].partition("@")[0]
		self.log(channel, line)

		if not channel.startswith("#"): # server level
			return

		for n, mode in enumerate(modes):
			if args[n] == None: # channel mode
				if add_mode:
					self.channels[channel].modes.add(mode)
				else:
					self.channels[channel].modes.remove(mode)

			elif mode in tools.op_level.keys(): # user mode, op_level mode
				nick = args[n]
				op_level = tools.op_level[mode]
				if add_mode:
					self.channels[channel].privileges[nick] += op_level
				else:
					self.channels[channel].privileges[nick] -= op_level

			else: # user mode, non-op_level mode
				continue


	def signedOn(self):
		"""Called when the bot successfully connects to the server."""
		print(f"Signed on as {self.nickname}")
		self.whois(self.nickname)

		line = "*** Signed onto " + self.hostname + " as "
		line += self.nickname + "!" + self.username + "@" + self.host
		self.log(self.hostname, line)

		for channel in self.config.core.channels.split(","):
			self.join(channel)


	def kickedFrom(self, channel, kicker, message):
		"""Called when the bot is kicked from a channel."""
		line = "-!- " + self.nickname + " was kicked from " + channel
		line += " by " + kicker + " [" + message + "]"
		self.log(channel, line)

		self.channels.pop(channel)


	def nickChanged(self, nick):
		"""Called when the bot changes it's nickname."""
		line = "-!- you are now known as " + nick

		user = self.users.pop(self.nickname)
		self.users[nick] = user
		for key, channel in self.channels.items():
			self.log(key, line)

			channel.rename_user(self.nickname, nick)
		user.nick = nick
		self.nickname = nick


	## Actions the bot observes other users doing in the channel.
	## These will get called automatically.

	def userJoined(self, user, channel):
		"""Called when the bot sees another user join a channel."""
		nick, _, host = user.partition("!")

		line = "-!- " + nick + " " + "[" + host + "] has joined " + channel
		self.log(channel, line)

		if nick not in self.users:
			self.users[nick] = tools.User(nick)
		self.channels[channel].add_user(self.users[nick])


	def userLeft(self, user, channel, reason=""):
		"""Called when the bot sees another user leave a channel."""
		nick, _, host = user.partition("!")

		line = "-!- " + nick + " " + "[" + host + "] has left "
		line += channel + " [" + reason + "]"
		self.log(channel, line)

		self.channels[channel].remove_user(nick)


	def userQuit(self, user, quitMessage):
		"""Called when the bot sees another user disconnect from the network."""
		nick, _, host = user.partition("!")
		line = "-!- " + nick + " [" + host + "] has quit [" + quitMessage + "]"

		channels = list(self.users[nick].channels.keys())
		for channel in channels:
			self.log(channel, line)

			self.channels[channel].remove_user(nick)
		self.users.pop(nick)


	def userKicked(self, kickee, channel, kicker, message):
		"""
		Called when the bot sees another user getting kicked from the channel.
		"""
		line = "-!- " + kickee + " was kicked from " + channel
		line += " by " + kicker + " [" + message + "]"
		self.log(channel, line)

		self.channels[channel].remove_user(kickee)


	def topicUpdated(self, user, channel, newTopic):
		"""Called when the bot sees a user update the channel's topic."""
		line = "-!- " + user + " changed the topic of " + channel + " to: "
		line += newTopic
		self.log(channel, line)

		self.channels[channel].topic = newTopic


	def userRenamed(self, oldname, newname):
		"""Called when the bot sees a user change their nickname."""
		line = "-!- " + oldname + " is now known as " + newname

		user = self.users.pop(oldname)
		self.users[newname] = user
		for key, channel in user.channels.items():
			self.log(key, line)

			channel.rename_user(oldname, newname)
		user.nick = newname


	def namesReceived(self, channel, channel_type, nicklist):
		"""
		Called when the bot receives a list of names in the channel from the
		server.
		"""
		self.channels[channel].channel_type = channel_type
		for nick in nicklist:
			op_level = tools.op_level.get(nick[0], 0)
			if op_level > 0:
				nick = nick[1:]
			self.users[nick] = tools.User(nick)
			self.channels[channel].add_user(self.users[nick])
			self.channels[channel].privileges[nick] = op_level


	def whoisUser(self, nick, ident, host, realname):
		"""
		Called when the bot receives a WHOIS about a particular user.
		"""
		if nick == self.nickname:
			self.username = ident
			self.host = host
			self.realname = realname
	

	def whoisIdle(self, nick, idle, signon):
		"""
		Called when the bot receives a WHOIS about a particular user.
		nick - nickname of the user
		idle - seconds since last activity from user
		signon - unix timestamp when user signed on
		"""
		if self.memory.get("idle_callbacks"):
			self.memory["idle_callbacks"][nick].callback((nick, idle, signon))
			self.memory["idle_callbacks"].pop(nick)


	## User commands, from client->server

	def msg(self, user, message, length=None):
		"""
		Sends a message 'message' to 'user' (can be a user or a channel).
		If 'length' is specified, the message will be split into lengths
		of that size. If 'length' is not specified, the bot will determine
		an appropriate length automatically.
		"""
		if user.startswith("#"):
			priv = self.channels[user].privileges[self.nickname]
			opSym = tools.getOpSym(priv)
		else:
			opSym = ""
		line = "<" + opSym + self.nickname + ">" + " " + message
		self.log(user, line)

		irc.IRCClient.msg(self, user, message, length=None)


	def reply(self, text, dest, reply_to, notice=False):
		"""
		Sends a message to 'dest' prefixed with 'reply_to' and a colon,
		ala "reply_to: text". More useful with the wrapper class.
		"""
		text = reply_to + ": " + text
		self.msg(dest, text)


	def quit(self, message=""):
		"""
		Disconnects from quitting normally results in the factory
		reconnecting us, so we need to include shutting down the factory.
		"""
		print("Quit from server")
		irc.IRCClient.quit(self, message)
		self.factory.stopTrying()
		sys.exit(0) # why doesn't this work?


	## Raw server->client messages

	def irc_RPL_NAMREPLY(self, prefix, params):
		"""
		Called when we have received a list of names in the channel from the
		server.
		"""
		channel_types = {"@": "secret", "*": "private", "=": "public"}
		channel_type = channel_types[params[1]]
		channel = params[2]
		nicklist = params[3].split()
		self.namesReceived(channel, channel_type, nicklist)


	def irc_JOIN(self, prefix, params):
		"""
		Called when a user joins a channel.
		"""
		nick = prefix.split('!')[0]
		channel = params[-1]
		if nick == self.nickname:
			self.joined(channel)
		else:
			self.userJoined(prefix, channel)


	def irc_PART(self, prefix, params):
		"""
		Called when a user leaves a channel.
		"""
		nick = prefix.split('!')[0]
		channel = params[0]
		if len(params) > 1:
			reason = params[1]
		else:
			reason = ""

		if nick == self.nickname:
			self.left(channel, reason)
		else:
			self.userLeft(prefix, channel, reason)


	def irc_QUIT(self, prefix, params):
		"""
		Called when a user has quit.
		"""
		nick = prefix.split('!')[0]
		self.userQuit(prefix, params[0])


	def irc_RPL_WHOISUSER(self, prefix, params):
		"""
		Called when we receive the server's response from our "WHOIS [user]"
		query. Contains hostmask information.
		"""
		_, nick, ident, host, _, realname = params
		self.whoisUser(nick, ident, host, realname)


	def irc_RPL_WHOISIDLE(self, prefix, params):
		"""
		Called when we receive the server's response from our "WHOIS [user]"
		query. Contains idle and signon time information.
		"""
		_, nick, idle, signon, _ = params
		self.whoisIdle(nick, idle, signon)


class FulviaWrapper():
	"""
	A wrapper class for Fulvia to provide default destinations for msg
	methods and so forth.
	"""
	def __init__(self, fulvia, trigger):
		object.__setattr__(self, '_bot', fulvia)
		object.__setattr__(self, '_trigger', trigger)
		# directly setting these values would cause a recursion loop
		# overflow

	def __getattr__(self, attr):
		"""Redirects getting attributes to the master bot instance."""
		return getattr(self._bot, attr)

	def __setattr__(self, attr, value):
		"""Redirects setting attributes to the master bot instance."""
		return setattr(self._bot, attr, value)

	def msg(self, user=None, message=None, length=None):
		"""
		If user is None it will default to the channel the message was
		received on.
		"""
		if user == None:
			raise TypeError("msg() missing 2 required positional " \
				+ "arguments: 'user' and 'message'")
		if message == None:
			# assume the first argument is the message
			message = user
			user = self._trigger.channel
		self._bot.msg(user, message, length)

	def reply(self, message, destination=None, reply_to=None, notice=False):
		"""
		If destination is None, it defaults to the channel the message
		was received on.
		If reply_to is None, it defaults to the person who sent the
		message.
		"""
		if destination is None:
			destination = self._trigger.channel
		if reply_to is None:
			reply_to = self._trigger.nick
		self._bot.reply(message, destination, reply_to, notice)


class FulviaFactory(protocol.ReconnectingClientFactory):
	# black magic going on here
	protocol = property(lambda s: functools.partial(Fulvia, s.config))

	def __init__(self, config):
		self.config = config