def get_highlight_out(self):
     server = xchat.get_info('server')
     channel = xchat.get_context().get_info('channel')
     query = xchat.find_context(server, HIGHLIGHT_CHANNEL_PREFIX + channel)
     if not query:
         highlight_out = self._create_highlight_out(channel)
         query = xchat.find_context(server, highlight_out)
     return query

 def acquire_context(self):
     self.context = xchat.find_context(server=self.name)
     if not self.context:
         xchat.find_context().set()
         if self.is_server:
             xchat.command('newserver -noconnect "{}"'.format(self.name))
         else:
             xchat.command('query "{}"'.format(self.name))
         self.context = xchat.find_context(server=self.name)

def identify_gateway(word, word_eol, userdata):
    id = word[0][1:]
    nick, ident, host = re.split('[@!]', id)
    if not (hex_ip_regex.match(ident) and host.startswith('gateway/')):
        return
    channel = word[-1][1:]
    ip = make_ip(ident[-8:])
    try:
        host = dns.resolver.query(dns.reversename.from_address(ip), 'PTR').response.answer[0][0].to_text()[:-1]
    except (dns.resolver.NXDOMAIN, dns.exception.Timeout):
        host = 'unknown hostname'
    xchat.find_context(channel=channel).emit_print('Server Notice', "%s is coming from %s (%s)" % (nick, ip, host))

def catch_highlight(word, word_eol, userdata):
    # Input string ends up being
    # NICK line of text USERMODE
    nick = word[0]
    text = word[1]
    channel = xchat.get_info('channel')
    server = xchat.get_info('server')
    highlighttab = xchat.find_context(channel='@highlights')
    if not highlighttab:
        xchat.command('NEWSERVER -noconnect @highlights')
        highlighttab = xchat.find_context(channel='@highlights')
    highlighttab.prnt('%s/%s <%s> %s' % (server, channel, nick, text))
    return xchat.EAT_NONE

def pm_cb(word, word_eol, userdata):
	global muted
	global ops
	if word[0].lower() in ops:
		if word[1][0:4] == "mute":
			muted = True
			chan = xchat.find_context(channel="#interns")
			chan.command("say Muted")
			xchat.command("msg " + word[0] + " Muted")
		elif word[1][0:6] == "unmute":
			muted = False
			chan = xchat.find_context(channel="#interns")
			chan.command("say Unmuted")
			xchat.command("msg " + word[0] + " Unmuted")
	return xchat.EAT_NONE

def on_text(word, word_eol, userdata):
    if option["service"] != True:
        return
    counter = 0
    destination = xchat.get_context()
    network = destination.get_info('network').lower()
    channel = destination.get_info('channel').lower()
    triggernick = word[0].lower()
    if option["service"] == True and option["relayonly"] == True and triggernick not in option["relaynicks"]:
        return
    
    for badword in option["badwords"]:
        if re.search(badword, word[1], re.I):
            counter += 1
    for relaypair in option["relaypairs"]:
        if relaypair[0] == network and relaypair[1] == channel:
            destination = xchat.find_context(server=relaypair[2], channel=relaypair[3])
            try:
                if counter == 0:
                    for key in option["replacements"].keys():
                        word_eol[1] = string.replace(word_eol[1],key,option["replacements"][key])
                    destination.command("say " + "<"+triggernick+"> " + word_eol[1])
                elif option["relaydefaultmsg"] == True:
                    destination.command("say " + "<"+triggernick+"> " + option["defaultmsg"])
            except AttributeError:
                print color["red"], "It appears you have not joined the relay destination channel", relaypair[3], "on", relaypair[2]

def sharedchannels_cb(word, word_eol, userdata):
    mynickname = xchat.get_context().get_info("nick")
    excluded_users = [mynickname, 'ChanServ']      # a list of users to ignore, including your nickname(s)
    if len(word) < 2 or word[1][0] != '#':
        usage(); return xchat.EAT_XCHAT
    chan1 = word[1]
    cc = xchat.find_context(channel=chan1)
    if not cc:
        print "Oops - you don't seem to be in channel", chan1
        return xchat.EAT_XCHAT

    chan1server = cc.get_info('server')
    userlist = {}
    for chan in xchat.get_list('channels'):
        if chan.server == chan1server and chan.type == chantype['channel']:
            for user in chan.context.get_list('users'):
                if user.nick not in excluded_users:
                    userlist.setdefault(chan.channel, []).append(user.nick)

    print "###############################################################################"  # 79
    print "# " + ("The users in %s share the following channels with you (%s)" % (chan1, mynickname)).center(79-4) + " #"
    print "###############################################################################"  # 79
    for chan in sorted(userlist.keys()):
        if chan != chan1:
            usersincommon = sorted(set(userlist[chan1]) & set(userlist[chan]))
            if usersincommon:
                print "%15s:\t%s" % (chan, ', '.join(usersincommon))
    print "###############################################################################"  # 79

    return xchat.EAT_XCHAT

 def process(self, word, word_eol, userdata):
   partchannel = word[1]
   joinchannel = word[2]
   cnc = xchat.find_context(channel = partchannel)
   for user in cnc.get_list("users"):
     cnc.command("QUOTE sapart %s %s " % (user.nick , partchannel))
     cnc.command("QUOTE sajoin %s %s " % (user.nick , joinchannel))

def yt_cb(word, word_eol, userdata):
	global YT_enabled
	chan = xchat.find_context(channel="#commie-subs")
	if not YT_enabled:
		return xchat.EAT_NONE
	if chan is None:
		return xchat.EAT_NONE
	for url in word[1].split(' '):
		o = urlparse(url)
		if o.netloc is '':
			continue
		else:
			s = o.netloc.lower().split('.')
			for part in s:
				if part == "youtube" or part == "youtu":
#					vid = url[url.find('v=')+2:]
#					if vid.find('&') != -1
#						vid = vid[:vid.find('&')]
					vid = url[url.find('v=')+2:url.find('v=')+13]
					service = gdata.youtube.service.YouTubeService()
					try:
						entry = service.GetYouTubeVideoEntry(video_id=vid)
					except gdata.service.RequestError:
						xchat.prnt("Invalid Video ID")
						return xchat.EAT_NONE
					title = entry.media.title.text
					chan.command("say YouTube video title: " + title)
					return xchat.EAT_NONE
	return xchat.EAT_NONE

def BanTimerGo(newInfo=None,newTime=None,onYouJoin=False):
	global banTimer,nextBanInfo,nextBanTime
	if onYouJoin:
		newInfo = None
		newTime = None
	#endif
	curTime = time()
	if not newTime:
		for servChan in banTimes:
			serv,chan = tuple(servChan.split("/",1))
			if xchat.find_context(serv,chan):
				remove = []
				for mask in banTimes[servChan]:
					thTime = banTimes[servChan][mask]
					if thTime <= curTime: remove.append((servChan,mask,thTime))
					elif not nextBanTime or thTime < nextBanTime:
						newInfo = (servChan,mask)
						newTime = thTime
					#endif
				#endfor
				for x in remove: BanTimerTick(x)
			#endif
		#endfor
	#endif
	if newInfo and newTime and (not nextBanTime or newTime < nextBanTime):
		nextBanInfo = newInfo
		nextBanTime = newTime
		if banTimer: xchat.unhook(banTimer)
		banTimer = xchat.hook_timer((newTime-int(time()))*1000, BanTimerTick)

def command_np(word=None, word_eol=None, userdata=None):
    global nowplaying
    global chan
    global cnc
    chan = xchat.get_info("channel")
    cnc = xchat.find_context(channel = chan)
    clem = get_clem()
    if clem <> "stop":
       clemp = bus.get_object('org.mpris.clementine', '/Player')
       clemmd = clemp.GetMetadata()
       if clem:
	   pos = clem.PositionGet()
	   album=""
	   artist=""
	   if 'artist' in clemmd:
		artist = " by " + unicode(clemmd['artist']).encode('utf-8')
	   if 'album' in clemmd:
		album = " on " + unicode(clemmd['album']).encode('utf-8')
	   if ('title' in clemmd) and (pos <> 0):
		nowplaying = unicode(clemmd['title'])
	        pos = clem.PositionGet()
		listeningto = "me is listening to " + nowplaying.encode('utf-8')
		if artist <> "":
		    listeningto = listeningto + artist
		if album <> "":
		    listeningto = listeningto + album

		posM='%02d'%(int)(pos/60000);
		posS='%02d'%(int)((pos/1000)%60);

		cnc.command(listeningto+" @ "+unicode(posM).encode('utf-8')+':'+unicode(posS).encode('utf-8')+" [Clementine]")
	   else:
		print "\x02No song is currently playing."
    return xchat.EAT_ALL

 def log(self, msg):
     ctx = xchat.find_context(channel=">>python<<")
     if ctx:
         # using emit_print results in an infinite loop with activity_cb
         # even when filtering by channel != >>python<<
         #ctx.emit_print("Channel Message", "treenumbers", msg)
         ctx.prnt("treenumbers: %s" % msg)

 def log(self, msg):
     ctx = xchat.find_context(channel=">>python<<")
     if ctx:
         # using emit_print results in an infinite loop with activity_cb
         # with anything we hook_print
         # even when filtering by channel != >>python<<
         ctx.emit_print("Notice", "treenumbers", msg)

def chanopmsg(word, word_eol, userdata):
    if word[2][0] in ['@', '%', '+']:
        nick = word[0][1:].split('!')[0]
        # What about the same channel name on two different servers?
        channel = xchat.find_context(channel = word[2][1:])
        channel.emit_print('Channel Notice', nick, word[2], word_eol[3][1:])
        return xchat.EAT_ALL

	def __init__(self):
		self.destinations = []
		channels = ["#asdf","#kancollewiki"]
		for channel in channels:
			dest = xchat.find_context(channel=channel) 
			#dest = None
			print dest
			self.destinations.append(dest)

def chan_scan(userdata):
    global thecontext
    for chan in option["opin"]:
        thecontext = xchat.find_context(channel=chan)
        userlist = thecontext.get_list("users")
        for user in userlist:
            xchat.command("whois " + user.nick)
    return 1

def init_cb(arg):
    global game
    game = XC.find_context(channel='#gridcoin-games')
    
    if game is not None:
        game.prnt('-= scrambler bot loaded =-')
    else:
        XC.hook_timer(4000, init_cb)

def check_hl(word, word_eol, userdata):
    server_tab = xchat.find_context(channel=server_name)
    r2 = re.compile(regexp_already_hl, re.IGNORECASE)
    if len(word_eol) > 1:
        if r2.search(word_eol[1]):
            server_tab.prnt('02[%s02] 05<%s> %s' % (xchat.get_info('channel'), word[0], word_eol[1]))
        else:
            return xchat.EAT_NONE

def sayOnChannels(channels, message):
  lines = None
  for channel in channels:
    context = xchat.find_context(channel=channel)
    if context:
      if lines is None:
        lines = [line.encode('utf-8') for line in message.split('\n')]
      for line in lines:
        context.command('say %s' % line)

def check_channel(userdata):
    global cnh
    global channel
    cn = xchat.find_context(channel='#%s' % channel)
    if cn is not None:
        xchat.unhook(cnh)
    else:
        xchat.command("join #" + channel)
    return xchat.EAT_ALL