# $Id$
#
# SIP Conference Bot
#
# Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
#
import pjsua as pj
import string
import sys

CFG_FILE = "config"

INFO = 1
TRACE = 2
	
# Call callback. This would just forward the event to the Member class
class CallCb(pj.CallCallback):
	def __init__(self, member, call=None):
		pj.CallCallback.__init__(self, call)
		self.member = member
	
	def on_state(self):
		self.member.on_call_state(self.call)
	
	def on_media_state(self):
		self.member.on_call_media_state(self.call)

	def on_dtmf_digit(self, digits):
		self.member.on_call_dtmf_digit(self.call, digits)

	def on_transfer_request(self, dst, code):
		return self.member.on_call_transfer_request(self.call, dst, code)
	
	def on_transfer_status(self, code, reason, final, cont):
		return self.member.on_call_transfer_status(self.call, code, reason, final, cont)

	def on_replace_request(self, code, reason):
		return self.member.on_call_replace_request(self.call, code, reason)
		
	def on_replaced(self, new_call):
		self.member.on_call_replaced(self.call, new_call)

	def on_typing(self, is_typing):
		self.member.on_typing(is_typing, call=self.call)

	def on_pager(self, mime_type, body):
		self.member.on_pager(mime_type, body, call=self.call)
	
	def on_pager_status(self, body, im_id, code, reason):
		self.member.on_pager_status(body, im_id, code, reason, call=self.call)

# Buddy callback. This would just forward the event to Member class
class BuddyCb(pj.BuddyCallback):
	def __init__(self, member, buddy=None):
		pj.BuddyCallback.__init__(self, buddy)
		self.member = member
	
	def on_pager(self, mime_type, body):
		self.member.on_pager(mime_type, body, buddy=self.buddy)

	def on_pager_status(self, body, im_id, code, reason):
		self.member.on_pager_status(body, im_id, code, reason, buddy=self.buddy)

	def on_state(self):
		self.member.on_pres_state(self.buddy)

	def on_typing(self, is_typing):
		self.member.on_typing(is_typing, buddy=self.buddy)




##############################################################################
#
#
# This class represents individual room member (either/both chat and voice conf)
#
#
class Member:
	def __init__(self, bot, uri):
		self.uri = uri
		self.bot = bot
		self.call = None
		self.buddy = None
		self.bi = pj.BuddyInfo()
		self.in_chat = False
		self.in_voice = False
		self.im_error = False
		self.html = False
	
	def __str__(self):
		str = string.ljust(self.uri, 30) + " -- " 
		if self.buddy:
			bi = self.buddy.info()
			str = str + bi.online_text
		else:
			str = str + "Offline"
		str = str + " ["
		if (self.in_voice):
			str = str + " voice"
		if (self.in_chat):
			str = str + " chat"
			if (self.html):
				str = str + " html"
			else:
				str = str + " plain"

		if (self.im_error):
			str = str + " im_error"
		str = str + "]"
		return str
		
	def join_call(self, call):
		if self.call:
			self.call.hangup(603, "You have been disconnected for making another call")
		self.call = call
		call.set_callback(CallCb(self, call))
		msg = "%(uri)s is attempting to join the voice conference" % \
			  {'uri': self.uri}
		self.bot.DEBUG(msg + "\n", INFO)
		self.bot.broadcast_pager(None, msg)
	
	def join_chat(self):
		if not self.buddy:
			self.bot.DEBUG(self.uri + " joining chatroom...\n", INFO)
			self.buddy = self.bot.acc.add_buddy(self.uri)
			self.buddy.set_callback(BuddyCb(self, self.buddy))
			self.buddy.subscribe()
		else:
			self.bot.DEBUG(self.uri + " already in chatroom, resubscribing..\n", INFO)
			self.buddy.subscribe()

	def send_pager(self, body, mime="text/plain"):
		self.bot.DEBUG("send_pager() to " + self.uri)
		if self.in_chat and not self.im_error and self.buddy:
			if self.html:
				#This will make us receive html!
				#mime = "text/html"
				body = body.replace("<", "&lt;")
				body = body.replace(">", "&gt;")
				body = body.replace('"', "&quot;")
				body = body.replace("\n", "<BR>\n")
			self.buddy.send_pager(body, content_type=mime)
			self.bot.DEBUG("..sent\n")
		else:
			self.bot.DEBUG("..not sent!\n")
		
	def on_call_state(self, call):
		ci = call.info()
		if ci.state==pj.CallState.DISCONNECTED:
			if self.in_voice:
				msg = "%(uri)s has left the voice conference (%(1)d/%(2)s)" % \
					  {'uri': self.uri, '1': ci.last_code, '2': ci.last_reason}
				self.bot.DEBUG(msg + "\n", INFO)
				self.bot.broadcast_pager(None, msg)
			self.in_voice = False
			self.call = None
			self.bot.on_member_left(self)
		elif ci.state==pj.CallState.CONFIRMED:
			msg = "%(uri)s has joined the voice conference" % \
				  {'uri': self.uri}
			self.bot.DEBUG(msg + "\n", INFO)
			self.bot.broadcast_pager(None, msg)
	
	def on_call_media_state(self, call):
		self.bot.DEBUG("Member.on_call_media_state\n")
		ci = call.info()
		if ci.conf_slot!=-1:
			if not self.in_voice:
				msg = self.uri + " call media is active"
				self.bot.broadcast_pager(None, msg)
			self.in_voice = True
			self.bot.add_to_voice_conf(self)
		else:
			if self.in_voice:
				msg = self.uri + " call media is inactive"
				self.bot.broadcast_pager(None, msg)
			self.in_voice = False

	def on_call_dtmf_digit(self, call, digits):
		msg = "%(uri)s sent DTMF digits %(dig)s" % \
			  {'uri': self.uri, 'dig': digits}
		self.bot.broadcast_pager(None, msg)

	def on_call_transfer_request(self, call, dst, code):
		msg = "%(uri)s is transfering the call to %(dst)s" % \
			  {'uri': self.uri, 'dst': dst}
		self.bot.broadcast_pager(None, msg)
		return 202
	
	def on_call_transfer_status(self, call, code, reason, final, cont):
		msg = "%(uri)s call transfer status is %(code)d/%(res)s" % \
			  {'uri': self.uri, 'code': code, 'res': reason}
		self.bot.broadcast_pager(None, msg)
		return True

	def on_call_replace_request(self, call, code, reason):
		msg = "%(uri)s is requesting call replace" % \
			  {'uri': self.uri}
		self.bot.broadcast_pager(None, msg)
		return (code, reason)
		
	def on_call_replaced(self, call, new_call):
		msg = "%(uri)s call is replaced" % \
			  {'uri': self.uri}
		self.bot.broadcast_pager(None, msg)

	def on_pres_state(self, buddy):
		old_bi = self.bi
		self.bi = buddy.info()
		msg = "%(uri)s status is %(st)s" % \
		  {'uri': self.uri, 'st': self.bi.online_text}
		self.bot.DEBUG(msg + "\n", INFO)
		self.bot.broadcast_pager(self, msg)

		if self.bi.sub_state==pj.SubscriptionState.ACTIVE:
			if not self.in_chat:
				self.in_chat = True
				buddy.send_pager("Welcome to chatroom")
				self.bot.broadcast_pager(self, self.uri + " has joined the chat room")
			else:
				self.in_chat = True
		elif self.bi.sub_state==pj.SubscriptionState.NULL or \
			 self.bi.sub_state==pj.SubscriptionState.TERMINATED or \
			 self.bi.sub_state==pj.SubscriptionState.UNKNOWN:
			self.buddy.delete()
			self.buddy = None
			if self.in_chat:
				self.in_chat = False
				self.bot.broadcast_pager(self, self.uri + " has left the chat room")
			else:
				self.in_chat = False
			self.bot.on_member_left(self)
		
	def on_typing(self, is_typing, call=None, buddy=None):
		if is_typing:
			msg = self.uri + " is typing..."
		else:
			msg = self.uri + " has stopped typing"
		self.bot.broadcast_pager(self, msg)

	def on_pager(self, mime_type, body, call=None, buddy=None):
		if not self.bot.handle_cmd(self, None, body):
			msg = self.uri + ": " + body
			self.bot.broadcast_pager(self, msg, mime_type)
	
	def on_pager_status(self, body, im_id, code, reason, call=None, buddy=None):
		self.im_error = (code/100 != 2)



##############################################################################
#
#
# The Bot instance (singleton)
#
#
class Bot(pj.AccountCallback):
	def __init__(self):
		pj.AccountCallback.__init__(self, None)
		self.lib = pj.Lib()
		self.acc = None
		self.calls = []
		self.members = {}
		self.cfg = None

	def DEBUG(self, msg, level=TRACE):
		print msg,
		
	def helpstring(self):
		return """
--h[elp]            Display this help screen
--j[oin]            Join the chat room
--html on|off       Set to receive HTML or plain text

Participant commands:
--s[how]            Show confbot settings
--leave             Leave the chatroom
--l[ist]            List all members

Admin commands:
--a[dmin] <CMD> Where <CMD> are:
    list            List the admins
    add <URI>       Add URI as admin
    del <URI>       Remove URI as admin
    rr              Reregister account to server
    call <URI>      Make call to the URI and add to voice conf
    dc <URI>        Disconnect call to URI
    hold <URI>      Hold call with that URI
    update <URI>    Send UPDATE to call with that URI
    reinvite <URI>  Send re-INVITE to call with that URI
"""

	def listmembers(self):
		msg = ""
		for uri, m in self.members.iteritems():
			msg = msg + str(m) + "\n"
		return msg
	
	def showsettings(self):
		ai = self.acc.info()
		msg = """
ConfBot status and settings:
  URI:        %(uri)s
  Status:     %(pres)s
  Reg Status: %(reg_st)d
  Reg Reason: %(reg_res)s
""" % {'uri': ai.uri, 'pres': ai.online_text, \
	   'reg_st': ai.reg_status, 'reg_res': ai.reg_reason}
		return msg
  
	def main(self, cfg_file):
		try:
			cfg = self.cfg = __import__(cfg_file)
			
			self.lib.init(ua_cfg=cfg.ua_cfg, log_cfg=cfg.log_cfg, media_cfg=cfg.media_cfg)
			self.lib.set_null_snd_dev()
			
			transport = None
			if cfg.udp_cfg:
				transport = self.lib.create_transport(pj.TransportType.UDP, cfg.udp_cfg)
			if cfg.tcp_cfg:
				t = self.lib.create_transport(pj.TransportType.TCP, cfg.tcp_cfg)
				if not transport:
					transport = t
				
			self.lib.start()
			
			if cfg.acc_cfg:
				self.DEBUG("Creating account %(uri)s..\n" % {'uri': cfg.acc_cfg.id}, INFO)
				self.acc = self.lib.create_account(cfg.acc_cfg, cb=self)
			else:
				self.DEBUG("Creating account for %(t)s..\n" % \
							{'t': transport.info().description}, INFO)
				self.acc = self.lib.create_account_for_transport(transport, cb=self)
			
			self.acc.set_basic_status(True)
			
			# Wait for ENTER before quitting
			print "Press q to quit or --help/--h for help"
			while True:
				input = sys.stdin.readline().strip(" \t\r\n")
				if not self.handle_cmd(None, None, input):
					if input=="q":
						break
			
			self.lib.destroy()
			self.lib = None

		except pj.Error, e:
			print "Exception: " + str(e)
			if self.lib:
				self.lib.destroy()
				self.lib = None
	
	def broadcast_pager(self, exclude_member, body, mime_type="text/plain"):
		self.DEBUG("Broadcast: " + body + "\n")
		for uri, m in self.members.iteritems():
			if m != exclude_member:
				m.send_pager(body, mime_type)

	def add_to_voice_conf(self, member):
		if not member.call:
			return
		src_ci = member.call.info()
		self.DEBUG("bot.add_to_voice_conf\n")
		for uri, m in self.members.iteritems():
			if m==member:
				continue
			if not m.call:
				continue
			dst_ci = m.call.info()
			if dst_ci.media_state==pj.MediaState.ACTIVE and dst_ci.conf_slot!=-1:
				self.lib.conf_connect(src_ci.conf_slot, dst_ci.conf_slot)
				self.lib.conf_connect(dst_ci.conf_slot, src_ci.conf_slot)
	
	def on_member_left(self, member):
		if not member.call and not member.buddy:
			del self.members[member.uri]
			del member
			
	def handle_admin_cmd(self, member, body):
		if member and self.cfg.admins and not member.uri in self.cfg.admins:
			member.send_pager("You are not admin")
			return
		args = body.split()
		msg = ""

		if len(args)==1:
			args.append(" ")

		if args[1]=="list":
			if not self.cfg.admins:
				msg = "Everyone is admin!"
			else:
				msg = str(self.cfg.admins)
		elif args[1]=="add":
			if len(args)!=3:
				msg = "Usage: add <URI>"
			else:
				self.cfg.admins.append(args[2])
				msg = args[2] + " added as admin"
		elif args[1]=="del":
			if len(args)!=3:
				msg = "Usage: del <URI>"
			elif args[2] not in self.cfg.admins:
				msg = args[2] + " is not admin"
			else:
				self.cfg.admins.remove(args[2])
				msg = args[2] + " has been removed from admins"
		elif args[1]=="rr":
			msg = "Reregistering.."
			self.acc.set_registration(True)
		elif args[1]=="call":
			if len(args)!=3:
				msg = "Usage: call <URI>"
			else:
				uri = args[2]
				try:
					call = self.acc.make_call(uri)
				except pj.Error, e:
					msg = "Error: " + str(e)
					call = None

				if call:
					if not uri in self.members:
						m = Member(self, uri)
						self.members[m.uri] = m
					else:
						m = self.members[uri]
					msg = "Adding " + m.uri + " to voice conference.."
					m.join_call(call)
		elif args[1]=="dc" or args[1]=="hold" or args[1]=="update" or args[1]=="reinvite":
			if len(args)!=3:
				msg = "Usage: " + args[1] + " <URI>"
			else:
				uri = args[2]
				if not uri in self.members:
					msg = "Member not found/URI doesn't match (note: case matters!)"
				else:
					m = self.members[uri]
					if m.call:
						if args[1]=="dc":
							msg = "Disconnecting.."
							m.call.hangup(603, "You're disconnected by admin")
						elif args[1]=="hold":
							msg = "Holding the call"
							m.call.hold()
						elif args[1]=="update":
							msg = "Sending UPDATE"
							m.call.update()
						elif args[1]=="reinvite":
							msg = "Sending re-INVITE"
							m.call.reinvite()
					else:
						msg = "He is not in call"
		else:
			msg = "Unknown admin command " + body

		#print "msg is '%(msg)s'" % {'msg': msg}

		if True:
			if member:
				member.send_pager(msg)
			else:
				print msg

	def handle_cmd(self, member, from_uri, body):
		body = body.strip(" \t\r\n")
		msg = ""
		handled = True
		if body=="--l" or body=="--list":
			msg = self.listmembers()
			if msg=="":
				msg = "Nobody is here"
		elif body[0:3]=="--s":
			msg = self.showsettings()
		elif body[0:6]=="--html" and member:
			if body[8:11]=="off":
				member.html = False
			else:
				member.html = True
		elif body=="--h" or body=="--help":
			msg = self.helpstring()
		elif body=="--leave":
			if not member or not member.buddy:
				msg = "You are not in chatroom"
			else:
				member.buddy.unsubscribe()
		elif body[0:3]=="--j":
			if not from_uri in self.members:
				m = Member(self, from_uri)
				self.members[m.uri] = m
				self.DEBUG("Adding " + m.uri + " to chatroom\n")
				m.join_chat()
			else:
				m = self.members[from_uri]
				self.DEBUG("Adding " + m.uri + " to chatroom\n")
				m.join_chat()
		elif body[0:3]=="--a":
			self.handle_admin_cmd(member, body)
			handled = True
		else:
			handled = False

		if msg:
			if member:
				member.send_pager(msg)
			elif from_uri:
				self.acc.send_pager(from_uri, msg);
			else:
				print msg
		return handled
	
	def on_incoming_call(self, call):
		self.DEBUG("on_incoming_call from %(uri)s\n" % {'uri': call.info().remote_uri}, INFO)
		ci = call.info()
		if not ci.remote_uri in self.members:
			m = Member(self, ci.remote_uri)
			self.members[m.uri] = m
			m.join_call(call)
		else:
			m = self.members[ci.remote_uri]
			m.join_call(call)
		call.answer(200)
	
	def on_incoming_subscribe(self, buddy, from_uri, contact_uri, pres_obj):
		self.DEBUG("on_incoming_subscribe from %(uri)s\n" % from_uri, INFO)
		return (200, 'OK')

	def on_reg_state(self):
		ai = self.acc.info()
		self.DEBUG("Registration state: %(code)d/%(reason)s\n" % \
					{'code': ai.reg_status, 'reason': ai.reg_reason}, INFO)
		if ai.reg_status/100==2 and ai.reg_expires > 0:
			self.acc.set_basic_status(True)

	def on_pager(self, from_uri, contact, mime_type, body):
		body = body.strip(" \t\r\n")
		if not self.handle_cmd(None, from_uri, body):
			self.acc.send_pager(from_uri, "You have not joined the chat room. Type '--join' to join or '--help' for the help")

	def on_pager_status(self, to_uri, body, im_id, code, reason):
		pass

	def on_typing(self, from_uri, contact, is_typing):
		pass




##############################################################################
#
#
# main()
#
#
if __name__ == "__main__":
	bot = Bot()
	bot.main(CFG_FILE)