from basemodel import ListStage
from mmsmanager import mmsmgr, MMSMessageInfo
from basemodel import Stage, EntryStage

from mmssmil import MMS_smilmake
import smsstage, runtime, config, utils, mmscomposestage, uiconfig, mmsconfig, status, baseui
from phonedb import phonedb

class MMSBoxactivateStage(smsstage.JobAndNotify):
	def __init__(self, boxtype, index):
		smsstage.JobAndNotify.__init__(self, _('Wait...'), cb=self.box_cb, icon=uiconfig.baloon_message_mms_icon)
		self.boxtype = boxtype
		self.index = index
		self.result = False

	def do_job(self):
		from mms_net_pdu import Parse_MMS
		mmsmgr.initmsg()
		mmsmgr.current_slide = 0
		if self.boxtype == mmsconfig.MMS_INBOX:
			mmsmgr.infoindex = 1000+self.index
			self.result = Parse_MMS(mmsmgr.inbox_info[self.index][0])
			try:
				if not mmsmgr.msg.info_inbox_sender:
					mmsmgr.msg.info_inbox_sender = mmsmgr.inbox_info[self.index][3]
					#Roxia Begin cmlim 06.06.12
					if 0 < mmsmgr.msg.info_inbox_sender.find('/'):
						mmsmgr.msg.info_inbox_sender = mmsmgr.msg.info_inbox_sender[:mmsmgr.msg.info_inbox_sender.find('/')]
					#Roxia End cmlim
			except:
				pass
			if not mmsmgr.msg.subject:
				mmsmgr.msg.subject = mmsmgr.inbox_info[self.index][5]
		elif self.boxtype == mmsconfig.MMS_OUTBOX:
			mmsmgr.infoindex = 2000+self.index
			self.result = Parse_MMS(mmsmgr.outbox_info[self.index][0])
			if not mmsmgr.msg.subject:
				mmsmgr.msg.subject = mmsmgr.outbox_info[self.index][4]
		elif self.boxtype == mmsconfig.MMS_SENTBOX:
			mmsmgr.infoindex = 3000+self.index
			self.result = Parse_MMS(mmsmgr.sentbox_info[self.index][0])
			if not mmsmgr.msg.subject:
				mmsmgr.msg.subject = mmsmgr.sentbox_info[self.index][4]
		elif self.boxtype == mmsconfig.MMS_DRAFTBOX:
			mmsmgr.infoindex = 4000+self.index
			self.result = Parse_MMS(mmsmgr.draftbox_info[self.index][0])
			if not mmsmgr.msg.subject:
				mmsmgr.msg.subject = mmsmgr.draftbox_info[self.index][4]

	def error_cb(self):
		mmsmgr.initmsg()
		runtime.manager.queue_backward(2)

	def success_cb(self):
		if self.boxtype == mmsconfig.MMS_INBOX:
			from mmsplayer import PlayStage
			runtime.manager.change_stage(PlayStage(mmsmgr.msg.media, mmsmgr.msg.fname_smil, True, mmsmgr.get_player_title()))
		elif self.boxtype == mmsconfig.MMS_OUTBOX or self.boxtype == mmsconfig.MMS_SENTBOX or\
			self.boxtype == mmsconfig.MMS_DRAFTBOX:
			runtime.manager.change_stage(mmscomposestage.MMSMsgViewer(True))
		else:
			rutime.manager.back_stage()

	def box_cb(self):
		self.success_cb()

	def handle_key(self, key):
		if key == config.Red:
			fstage = runtime.manager.find_stage('inboxlist')
			if fstage:
				runtime.manager.back_stage('inboxlist')
			else:
				runtime.manager.back_stage('outboxlist')
		else:
			smsstage.JobAndNotify.handle_key(self, key)

def MMSboxdeleteNotify_cb():
	boxtype, index = mmsmgr.MMSBoxtype()
	mmsmgr.remove_info(index, boxtype)

	_len = 0

	if boxtype == mmsconfig.MMS_INBOX:
		fstage = runtime.manager.find_stage('inboxlist')
		if fstage:
			jump = 'inboxlist'
		else:
			jump = 'messagehotkey'
		_len  = len(mmsmgr.inbox_info)
	else:
		jump = 'outboxlist'
		if boxtype == mmsconfig.MMS_OUTBOX:
			_len = len(mmsmgr.outbox_info)
		elif boxtype == mmsconfig.MMS_SENTBOX:
			_len = len(mmsmgr.sentbox_info)
		elif boxtype == mmsconfig.MMS_DRAFTBOX:
			_len = len(mmsmgr.draftbox_info)

	if _len <= 0:
		if jump == 'messagehotkey':
			runtime.manager.back_stage(jump)
		else:
			runtime.manager.back_stage(jump, isshow=False)
			runtime.manager.back_stage()
	else:
		runtime.manager.back_stage(jump)

def MMSInboxlist_activate(index):
	mmsmgr.initmsg()
	mmsmgr.infoindex = 1000+index
	_list, _isread = mmsmgr.box_list(mmsconfig.MMS_INBOX)
	if _isread[index] == 2:
		from mms_net_stage import MMS_Downloading_Stage
		runtime.manager.stack_stage(MMS_Downloading_Stage(mmsmgr.inbox_info[index]))
	else:
		from mms_net_pdu import Parse_MMS
		Parse_MMS(mmsmgr.inbox_info[index][0])
		mmsmgr.current_slide = 0
		if _isread[index] == 0:
			mmsmgr.inbox_info[index][2] = 1
			mmsmgr.save_infos(mmsconfig.MMS_INBOX)

		from mmsplayer import PlayStage
		runtime.manager.stack_stage(PlayStage(mmsmgr.msg.media, mmsmgr.msg.fname_smil, True, mmsmgr.get_player_title()))

class MMSInboxlistStage(ListStage):
	name = 'inboxlist'
	def __init__(self):
		self._list, self._isread = self.makelist()
		_title = _('INBOX MMS') + '(%d)'%len(mmsmgr.inbox_info)
		ListStage.__init__(self, self._list, title=_title)
		self.makeicon()

	def show(self):
		mmsmgr.MMS_Remove_Tempmsg()
		_list, _isread = self.makelist()
		if self._list != _list or self._isread!= _isread:
			self._list = _list
			self._isread = _isread
			self.change_choice(self._list)
			self.makeicon()
		ListStage.show(self)
		if self._isread[self.ui.get_focus()] == 2:
			self.ui.set_left(_('DOWNLOAD'))
		else:
			self.ui.set_left(_('OK'))
		_title = _('INBOX MMS') + '(%d)'%len(mmsmgr.inbox_info)
		self.ui.set_title(_title)

	def makeicon(self):
		self.ui.remove_all_icon_columns()
		list_icon = []
		for r in self._isread:
			if r == 0:
				list_icon.append(uiconfig.list_icon_mms_received)
			elif r == 2:
				list_icon.append(uiconfig.list_icon_mms_unload)
			else:
				list_icon.append(uiconfig.list_icon_mms_saved)
		self.ui.create_icon_column(70, tuple(list_icon))

	def makelist(self):
		return mmsmgr.box_list(mmsconfig.MMS_INBOX)

	def activate(self, index):
		if self._isread[index] == 2:
			from mms_net_stage import MMS_Downloading_Stage
			mmsmgr.initmsg()
			mmsmgr.infoindex = 1000+index
			runtime.manager.stack_stage(MMS_Downloading_Stage(mmsmgr.inbox_info[index]))
		else:
			runtime.manager.stack_stage(MMSBoxactivateStage(mmsconfig.MMS_INBOX, index))
			if self._isread[index] == 0:
				mmsmgr.inbox_info[index][2] = 1
				mmsmgr.save_infos(mmsconfig.MMS_INBOX)

	def back_activate_menu1(self):
		runtime.manager.stack_stage(MMSInboxoptions())

	def back_activate_menu2(self):
		pass

	def handle_key(self, key):
		if key in ('Up', 'Down'):
			result = ListStage.handle_key(self, key)
			if self._isread[self.ui.get_focus()] == 2:
				self.ui.set_left(_('DOWNLOAD'))
			else:
				self.ui.set_left(_('OK'))
			return result
		else:
			return ListStage.handle_key(self, key)


class MMSInboxoptions(ListStage):
	name = 'mmsinboxoptions'
	icon = uiconfig.message_mms_icon
	def __init__(self):
		if mmsmgr.msg.isdrm_forward:
			choice = (_('Delete'), _('Play'), _('Reply'), _('Modify'), _('Details'), _('Use number'))
		else:
			choice = (_('Delete'), _('Play'), _('Save object'), _('Reply'), _('Forward'), _('Modify'), _('Details'), _('Use number'))
		ListStage.__init__(self, choice, _('OPTIONS'))
		self.playmode = -1
		self.backup_address = None
		self.backup_rinfo = None

	def show(self):
		if self.backup_address:
			mmsmgr.msg.info_received = self.backup_address
			self.backup_address = None
		if self.backup_rinfo:
			mmsmgr.rinfo = self.backup_rinfo
			self.backup_rinfo = None
		status.save_callback = None
		ListStage.show(self)

	def destroy(self):
		mmsmgr.isforward = False
		ListStage.destroy(self)

	def activate(self, index):
		stage = None
		if mmsmgr.msg.isdrm_forward:
			if index == 0:
				runtime.manager.stack_stage(mmscomposestage.MMSYesNo(_('Delete MMS?'), self.yes_cb, self.no_cb))
			elif index == 1:
				from mmsplayer import PlayStage
				stage = PlayStage(mmsmgr.msg.media, mmsmgr.msg.fname_smil, False, mmsmgr.get_player_title())
			elif index == 2: stage = MMSInboxoptions_replay()
			elif index == 3:
				media, path_media, media_type, slide_list = mmsmgr.media_list()
				if len(media) <= 0:
					runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('No media')))
					return
				stage = mmscomposestage.MMSModify()
			elif index == 4: stage = mmscomposestage.MMSDetailStage()
			elif index == 5: stage = MMSOptions_usenumber()
		else:
			if index == 0:
				runtime.manager.stack_stage(mmscomposestage.MMSYesNo(_('Delete MMS?'), self.yes_cb, self.no_cb))
			elif index == 1:
				from mmsplayer import PlayStage
				stage = PlayStage(mmsmgr.msg.media, mmsmgr.msg.fname_smil, False, mmsmgr.get_player_title())
			elif index == 2:
				media, path_media, media_type, slide_list = mmsmgr.media_list(istext=False)
				if len(media) <= 0:
					runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('No media')))
					return
				stage = MMSInboxoptions_save()
			elif index == 3: stage = MMSInboxoptions_replay()
			elif index == 4:
				media, path_media, media_type, slide_list = mmsmgr.media_list()
				if len(media) <= 0:
					runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('No media')))
					return
				status.save_callback = mmscomposestage.save_callback
				self.backup_address = mmsmgr.msg.info_received
				self.backup_rinfo = mmsmgr.rinfo
				mmsmgr.msg.info_received = [[[],[],[]], [[],[],[]]]
				mmsmgr.rinfo = []
				mmsmgr.isforward = True
				stage = mmscomposestage.MMSInputaddress()
			elif index == 5:
				media, path_media, media_type, slide_list = mmsmgr.media_list()
				if len(media) <= 0:
					runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('No media')))
					return
				stage = mmscomposestage.MMSModify(isinbox=True)
			elif index == 6: stage = mmscomposestage.MMSDetailStage()
			elif index == 7: stage = MMSOptions_usenumber()

		if stage != None:
			runtime.manager.stack_stage(stage)

	def yes_cb(self):
		runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('MMS Delete'), MMSboxdeleteNotify_cb))

	def no_cb(self):
		runtime.manager.back_stage()

	def back_activate_menu1(self):
		pass

	def back_activate_menu2(self):
		runtime.manager.back_stage()

class MMSInboxoptions_save(ListStage):
	name = 'MMSInboxoptions_save'
	def __init__(self):
		self.player_pid = None
		self.sound = None
		self.media = []
		self.path_media = []
		self.media_type = []
		self.slide_list = []
		self.media, self.path_media, self.media_type, self.slide_list = mmsmgr.media_list(istext=False)#, mmsmgr.current_slide)
		if self.media:
			choice = tuple(self.media)
			ListStage.__init__(self, choice, _('SAVE OBJECT'), icon=None, titleimage=None, left=_('OK'), right=_('BACK'))
		else:
			runtime.manager.change_stage(mmscomposestage.MMSMessageNotify(_('No media')))
		self._type = -1

		self.audio_play_timer = None

	def show(self):
		focus = self.ui.get_focus()
		try:
			if self.media_type[focus] == 2:
				self.sound = self.path_media[focus]
				self.play_audio()
			else:
				self.stop_audio()
		except:
			pass
		self.makeicon(focus)
		ListStage.show(self)

	def makeicon(self, focus=-1):
		icons = []
		index = 0
		import os.path
		for w in self.media_type:
			if w == 0:
				icons.append(uiconfig.list_icon_text)
			elif w == 1:
				icons.append(uiconfig.list_icon_image)
			elif w == 2:
				try:
					ext = utils.get_ext(self.path_media[index])
					if ext.lower() == 'imy':
						icons.append(uiconfig.list_icon_melody_mono)
					else:
						icons.append(uiconfig.list_icon_melody_poly)
				except:
					icons.append(uiconfig.list_icon_melody_poly)
			elif w == 3:
				icons.append(uiconfig.list_icon_video_saved)
			index += 1
		self.ui.remove_all_icon_columns()
		resize = [25, 25]
		self.ui.create_icon_column(60, tuple(icons), resize)

	def activate(self, index):
		if not utils.check_free_storage():
			runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('Storage is short')))
			return
		path = ''
		message = ''
		if self.media_type[index] == 0:
			#assert self.media
			return
		elif self.media_type[index] == 1:
			message = _('Gallery is full!')
			path = config.image_wallpaper_dir
		elif self.media_type[index] == 2:
			import os.path
			message = _('Melodies gallery is full!')
			ext = ''
			filename = os.path.split(self.path_media[index])[-1]
			dot = filename.rfind('.')
			if dot >=0:
				ext = filename[dot+1:]
			if ext:
				if ext == 'imy':
					path = config.audio_other_dir
				else:
					path = config.audio_polyphonic_dir
			else:
				path = config.audio_other_dir
		elif self.media_type[index] == 3:
			message = _('Video gallery is full!')
			path = config.video_received_dir

		if config.media_save_max <= utils.get_file_count(path):
			runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(message))
			return
		self._type = self.media_type[index]
		runtime.manager.stack_stage(MMSChangename(index, self.media[index], self.media_type[index], self.slide_list[index]))

	def hide(self):
		self.audio_play_timer = None
		self.stop_audio()
		ListStage.hide(self)

	def destroy(self):
		self.audio_play_timer = None
		self.stop_audio()
		ListStage.destroy(self)

	def play_audio(self):
		if not self.sound and status.phone_status != status.Disconnected:
			return
		self.player_pid = utils.player.play(self.sound)

	def stop_audio(self):
		if not self.sound and status.phone_status != status.Disconnected:
			return
		utils.player.stop(self.player_pid)

	def play_audio_cb(self):
		self.play_audio()
		self.audio_play_timer = None

	def handle_key(self, key):
		if key in ('Up', 'Down'):
			ret = ListStage.handle_key(self, key)
			ListStage.show(self)
			runtime.evas.render_now()
			focus = self.ui.get_focus()
			self.audio_play_timer = None
			try:
				if self.media_type[focus] == 2:
					self.sound = self.path_media[focus]
					self.audio_play_timer = utils.Timer(300, self.play_audio_cb)
				else:
					self.stop_audio()
			except:
				pass
			return ret
		else:
			return ListStage.handle_key(self, key)

class MMSChangename(EntryStage):
	def __init__(self, index, media, media_type, nslide):
		self.index = index
		self.media = media
		self.media_type = media_type
		self.nslide = nslide

		EntryStage.__init__(self, _('Name'), _('RENAME'))
		last_dot = media.rfind('.')
		media = media[:last_dot]
		try:
			self.ui.set_text(str(media[:16]))
		except:
			self.ui.set_text(str(media))
		self.ui.set_max(16)
		self.ui.set_automata('multitap', 'lower')
		self.ui.automata_idx = 3
		self.save_pos = 0	#1 ->other

	def activate_menu1(self):
		text = self.ui.get_text()
		ext = ''
		if len(text) <= 0:
			runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('No text inserted.')))
		else:
			if self.media_type == 0:
				return
			elif self.media_type == 1:
				src_fname = mmsmgr.msg.media[self.nslide].fname_image
				try:
					ext = utils.get_ext(mmsmgr.msg.media[self.nslide].fname_image)
					dst_fname = config.image_wallpaper_dir+text+'.'+ext
				except:
					dst_fname = config.image_wallpaper_dir+text
			elif self.media_type == 2:
				src_fname = mmsmgr.msg.media[self.nslide].fname_sound
				try:
					ext = utils.get_ext(mmsmgr.msg.media[self.nslide].fname_sound)
					dst_fname = text+'.'+ext
				except:
					dst_fname = text
				if ext:
					if ext == 'imy':
						self.save_pos = 1
						dst_fname = config.audio_other_dir + dst_fname
					else:
						dst_fname = config.audio_polyphonic_dir  + dst_fname
				else:
					dst_fname = config.audio_other_dir  + dst_fname
			elif self.media_type == 3:
				src_fname = mmsmgr.msg.media[self.nslide].fname_video
				try:
					ext = utils.get_ext(mmsmgr.msg.media[self.nslide].fname_video)
					dst_fname = config.video_received_dir+text+'.'+ext
				except:
					dst_fname = config.video_received_dir+text

			import os.path
			if not os.path.exists(src_fname):
				runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('The file does not exist')))
				return
			if os.path.exists(dst_fname):
				runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('The file exists already')))
				return

			if not utils.check_free_storage():
				runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('Storage is short')))
				return
			try:
				utils.file_copy(src_fname, dst_fname)
				try:
					if self.media_type == 3:
						image_dstf = ''
						image_srcf = ''
						path_dstf = os.path.split(dst_fname)
						dot = path_dstf[-1].rfind('.')
						image_dstf = config.video_received_thumnail_dir + path_dstf[-1][:dot] + '.png'

						path_srcf = os.path.split(src_fname)
						dot = path_srcf[-1].rfind('.')
						image_srcf = path_srcf[0] + '/' + path_srcf[-1][:dot] + '.png'
						utils.file_copy(image_srcf, image_dstf)
				except:
					pass

				fstage = runtime.manager.find_stage('MMSInboxoptions_save')
				fstage.media.pop(self.index)
				fstage.path_media.pop(self.index)
				fstage.media_type.pop(self.index)
				fstage.slide_list.pop(self.index)
				runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('Saving'), self.MMSObjectsave_cb))
			except:
				runtime.manager.change_stage(mmscomposestage.MMSMessageNotify(_('Copy failed')))

	def MMSObjectsave_cb(self):
		fstage = runtime.manager.find_stage('MMSInboxoptions_save')
		if fstage._type == 1:
			if self.save_pos == 1:
				runtime.manager.change_stage(mmscomposestage.MMSMessageNotify(_('Saved in pictures gallery'), self.MMSObjectsave_cb2))
			else:
				runtime.manager.change_stage(mmscomposestage.MMSMessageNotify(_('Saved in wallpapers gallery'), self.MMSObjectsave_cb2))
		elif fstage._type == 2:
			if self.save_pos == 1:
				runtime.manager.change_stage(mmscomposestage.MMSMessageNotify(_('Saved in other melodies gallery'), self.MMSObjectsave_cb2))
			else:
				runtime.manager.change_stage(mmscomposestage.MMSMessageNotify(_('Saved in ployphonic melodies gallery'), self.MMSObjectsave_cb2))
		elif fstage._type == 3:
			runtime.manager.change_stage(mmscomposestage.MMSMessageNotify(_('Saved in received videos gallery'), self.MMSObjectsave_cb2))
		else:
			pass
			#assert False, 'media type error'

	def MMSObjectsave_cb2(self):
		runtime.manager.back_stage('mmsinboxoptions')


class MMSInboxoptions_replay(ListStage):
	icon = uiconfig.message_mms_icon
	def __init__(self):
		title = _('REPLY')
		choice = (_('By SMS'), _('By MMS'))
		ListStage.__init__(self, choice, title)
		self.index = -1

		self.current_slide = -1
		self.rinfo = []
		self.rinfo_index = -1
		self.infoindex = -1
		self.msg = None

	def show(self):
		status.save_callback = None
		ListStage.show(self)
		if self.msg:
			mmsconfig.issend_mms = False
			if self.index == 1:
				self.manager_load()
				self.index = -1

	def activate(self, index):
		self.index = index
		box, pos = mmsmgr.MMSBoxtype()
		if index == 0:
			ret = mmsmgr.inbox_info[pos][3].split(':')
			tnum = ''
			if len(ret) == 2:
				tnum = ret[1]

			status.sms_phone_number = ret[0]
			if tnum:
				status.callee_terminal_number = tnum
			runtime.manager.stack_stage(smsstage.SmsCompose('new'))
		elif index == 1:
			self.manager_save()
			mmsmgr.initmsg()
			mmsmgr.load_message()
			mmsmgr.reply_address = mmsmgr.get_reply_number(mmsmgr.inbox_info[pos][3])
			status.save_callback = mmscomposestage.save_callback
			mmsmgr.isreply_mms = True
			runtime.manager.stack_stage(mmscomposestage.MMSCreateStage())
			mmsconfig.issend_mms = True

	def manager_save(self):
		self.current_slide = mmsmgr.current_slide
		self.rinfo = mmsmgr.rinfo
		self.rinfo_index = mmsmgr.rinfo_index
		self.infoindex = mmsmgr.infoindex
		import copy
		self.msg = copy.copy(mmsmgr.msg)

	def manager_load(self):
		mmsmgr.current_slide = self.current_slide
		mmsmgr.rinfo = self.rinfo
		mmsmgr.rinfo_index = self.rinfo_index
		mmsmgr.infoindex = self.infoindex
		import copy
		mmsmgr.msg = None
		mmsmgr.msg = copy.copy(self.msg)


def MMSGet_numbers_from_message():
	import os.path
	def get_number(s):
		s = s.replace('-', '')
		# 최대 18, 최소 3
		if not s.isdigit() or len(s) < 3 or len(s) > 50:
			return
		return s

	numbers = []

	for m in mmsmgr.msg.media:
		if m.fname_text:
			if os.path.exists(m.fname_text):
				fp = open(m.fname_text)
				text = fp.read()
				fp.close()
				if text:
					text = text.strip()
					textlist = text.split()
					for c in textlist:
						c=c.strip()
						number = get_number(c)
						if number:
							numbers.append(number)
	return numbers

class MMSOptions_usenumber(ListStage):
	title = _('USE NUMBER')
	icon = uiconfig.message_mms_icon
	def __init__(self):
		boxtype, pos = mmsmgr.MMSBoxtype()
		self.choice = []
		if boxtype == mmsconfig.MMS_INBOX:
			if mmsmgr.inbox_info[pos][3] and mmsmgr.inbox_info[pos][3].isdigit():
				self.choice.append(mmsmgr.inbox_info[pos][3])
		elif boxtype == mmsconfig.MMS_OUTBOX:
			if mmsmgr.outbox_info[pos][2] and mmsmgr.outbox_info[pos][2].isdigit():
				self.choice.append(mmsmgr.outbox_info[pos][2])
		elif boxtype == mmsconfig.MMS_SENTBOX:
			if mmsmgr.sentbox_info[pos][2] and mmsmgr.sentbox_info[pos][2].isdigit():
				self.choice.append(mmsmgr.sentbox_info[pos][2])
		elif boxtype == mmsconfig.MMS_DRAFTBOX:
			if mmsmgr.draftbox_info[pos][2] and mmsmgr.draftbox_info[pos][2].isdigit():
				self.choice.append(mmsmgr.draftbox_info[pos][2])
		self.choice += MMSGet_numbers_from_message()

		ListStage.__init__(self, self.choice, _('USE NUMBER'), None, None, _('OPTIONS'), _('BACK'))

		if len(self.choice) == 0:
			self.no_num_tag = utils.Idle(self.launch_nonum_notify)

	def launch_nonum_notify(self):
		runtime.manager.change_stage(mmscomposestage.MMSMessageNotify(_('No numbers found')))
		return False

	def handle_key(self, key):
		if key in (config.OffHook, config.Green):
			status.dial_number = self.choice[self.ui.get_focus()]
			return False
		return ListStage.handle_key(self, key)

	def activate(self, index):
		runtime.manager.stack_stage(MMSUsenumberStage(self.choice[index]))

class SaveStage(EntryStage):
	# Page 39에 의한 Save
	def __init__(self, num):
		EntryStage.__init__(self, _('Name'), _('SAVE'))
		self.ui.set_max(config.max_pb_name)
		status.phone_item = phonedb.new_item()
		if len(num) > config.max_phone_number:
			num = num[:config.max_phone_number]
		status.phone_item.number = num
		self.ui.set_automata('multitap', 'lower')
		self.ui.automata_idx = 3

	def activate_menu1(self):
		text = self.ui.get_text()
		status.phone_item.name = text

		import phonebook

		status.phonebook_save_stage_name = 'mmsusenumberstage'
		if phonedb.has_name(text):
			# name complict
			stage = phonebook.NameConflictStage()
			runtime.manager.stack_stage(stage)
			return
		phonebook.phone_item_save()

	def activate_menu2(self):
		runtime.manager.back_stage()

class MMSUsenumberStage(ListStage):
	title = _('Number')
	choice = (_('Save in phonebook'), _('Send SMS'), _('Send MMS'), _('Call'))
	name = 'mmsusenumberstage'
	icon = uiconfig.message_mms_icon
	def __init__(self, number):
		self.number = number
		self.index = -1
		ListStage.__init__(self)

		self.current_slide = -1
		self.rinfo = []
		self.rinfo_index = -1
		self.infoindex = -1
		self.msg = None

	def show(self):
		status.save_callback = None
		ListStage.show(self)
		if self.msg:
			mmsconfig.issend_mms = False
			if self.index == 2:
				self.manager_load()
				self.index = -1

	def activate(self, index):
		self.index = index
		if index == 0:
			import phonebook
			from phonedb import phonedb
			if phonedb.has_number(self.number):
				stage = phonebook.PhonebookNotifyStage(_('Number already in phonebook'))
				runtime.manager.stack_stage(stage)
				return

			# phonedb max size check
			if phonedb.count() >= config.phone_db_size:
				runtime.manager.stack_stage(phonebook.PhonebookNotifyStage(_('Memory full')))
				return
			runtime.manager.stack_stage(SaveStage(self.number))
		elif index == 1:
			status.sms_phone_number = self.number
			runtime.manager.stack_stage(smsstage.SmsCompose('new'))
		elif index == 2:
			mmsconfig.issend_mms = True
			self.manager_save()
			mmsmgr.initmsg()
			mmsmgr.load_message()
			mmsmgr.reply_address = mmsmgr.get_reply_number(self.number)
			status.save_callback = mmscomposestage.save_callback
			mmsmgr.isreply_mms = True
			runtime.manager.stack_stage(mmscomposestage.MMSCreateStage())
		elif index == 3:
			if status.phone_status == status.Disconnected:
				runtime.manager.start_call(self.number)

	def manager_save(self):
		self.current_slide = mmsmgr.current_slide
		self.rinfo = mmsmgr.rinfo
		self.rinfo_index = mmsmgr.rinfo_index
		self.infoindex = mmsmgr.infoindex
		import copy
		self.msg = copy.copy(mmsmgr.msg)

	def manager_load(self):
		mmsmgr.current_slide = self.current_slide
		mmsmgr.rinfo = self.rinfo
		mmsmgr.rinfo_index = self.rinfo_index
		mmsmgr.infoindex = self.infoindex
		import copy
		mmsmgr.msg = None
		mmsmgr.msg = copy.copy(self.msg)

class MMSOutboxlistStage(ListStage):
	name = 'outboxlist'
	def __init__(self, boxtype):
		self.boxtype = boxtype
		self._list, self._isread = self.makelist()

		if self.boxtype == mmsconfig.MMS_OUTBOX:
			_title = _('OUTBOX MMS')+'(%d)'%len(mmsmgr.outbox_info)
			_icon = uiconfig.message_mms_outbox_icon
		elif self.boxtype == mmsconfig.MMS_SENTBOX:
			_title = _('SENT MMS')+'(%d)'%len(mmsmgr.sentbox_info)
			_icon = uiconfig.message_mms_sent_icon
		elif self.boxtype == mmsconfig.MMS_DRAFTBOX:
			_title = _('DRAFT MMS')+'(%d)'%len(mmsmgr.draftbox_info)
			_icon = uiconfig.message_mms_draft_icon
		ListStage.__init__(self, self._list, title=_title, icon=_icon)

	def show(self):
		mmsmgr.MMS_Remove_Tempmsg()
		_list, _isread = self.makelist()
		if len(_list) <= 0:
			runtime.manager.back_stage()
			return
		if self._list != _list or self._isread != _isread:
			self._list = _list
			self._isread = _isread
			ListStage.change_choice(self, self._list)
		ListStage.show(self)
		if self.boxtype == mmsconfig.MMS_OUTBOX:
			_title = _('OUTBOX MMS')+'(%d)'%len(mmsmgr.outbox_info)
		elif self.boxtype == mmsconfig.MMS_SENTBOX:
			_title = _('SENT MMS')+'(%d)'%len(mmsmgr.sentbox_info)
		elif self.boxtype == mmsconfig.MMS_DRAFTBOX:
			_title = _('DRAFT MMS')+'(%d)'%len(mmsmgr.draftbox_info)
		self.ui.set_title(_title)

	def makelist(self):
		if self.boxtype == mmsconfig.MMS_OUTBOX:
			return mmsmgr.box_list(mmsconfig.MMS_OUTBOX)
		elif self.boxtype == mmsconfig.MMS_SENTBOX:
			return mmsmgr.box_list(mmsconfig.MMS_SENTBOX)
		elif self.boxtype == mmsconfig.MMS_DRAFTBOX:
			return mmsmgr.box_list(mmsconfig.MMS_DRAFTBOX)


	def activate(self, index):
		runtime.manager.stack_stage(MMSBoxactivateStage(self.boxtype, index))


class MMSOutboxoptions(ListStage):
	name = 'mmsoutboxoptions'
	def __init__(self):
		choice = (_('Delete'), _('Play'), _('Forward'), _('Modify'),  _('Details'), _('Use number'))
		boxtype, index = mmsmgr.MMSBoxtype()
		if boxtype == mmsconfig.MMS_OUTBOX:
			_icon = uiconfig.message_mms_outbox_icon
		elif boxtype == mmsconfig.MMS_SENTBOX:
			_icon = uiconfig.message_mms_sent_icon
		elif boxtype == mmsconfig.MMS_DRAFTBOX:
			_icon = uiconfig.message_mms_draft_icon
		else:
			_icon = uiconfig.message_mms_icon
		num = mmsmgr.slide_getcount()
		if num == 0:
			ListStage.__init__(self, choice, _('OPTIONS')+'[%d/%d]'%(num, num), _icon)
		else:
			ListStage.__init__(self, choice, _('OPTIONS')+'[%d/%d]'%(mmsmgr.current_slide+1, num), _icon)
		self.playmode = -1
		self.backup_address = None
		self.backup_rinfo = None

	def show(self):
		if self.backup_address:
			mmsmgr.msg.info_received = self.backup_address
			self.backup_address = None
		if self.backup_rinfo:
			mmsmgr.rinfo = self.backup_rinfo
			self.backup_rinfo = None
		status.save_callback = None
		ListStage.show(self)

	def destroy(self):
		mmsmgr.isforward = False
		ListStage.destroy(self)

	def activate(self, index):
		stage = None
		if index == 0:
			runtime.manager.stack_stage(mmscomposestage.MMSYesNo(_('Delete MMS?'), self.yes_cb, self.no_cb))
		elif index == 1:
			from mmsplayer import PlayStage
			stage = PlayStage(mmsmgr.msg.media, mmsmgr.msg.fname_smil, False, mmsmgr.get_player_title())
		elif index == 2:
			media, path_media, media_type, slide_list = mmsmgr.media_list()
			if len(media) <= 0:
				runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('No media')))
				return
			status.save_callback = mmscomposestage.save_callback
			self.backup_address = mmsmgr.msg.info_received
			self.backup_rinfo = mmsmgr.rinfo
			mmsmgr.msg.info_received = [[[],[],[]], [[],[],[]]]
			mmsmgr.rinfo = []
			mmsmgr.isforward = True
			stage = mmscomposestage.MMSInputaddress()
		elif index == 3:
			media, path_media, media_type, slide_list = mmsmgr.media_list()
			if len(media) <= 0:
				runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('No media')))
				return
			stage = mmscomposestage.MMSModify()
		elif index == 4: stage = mmscomposestage.MMSDetailStage()
		elif index == 5: stage = MMSOptions_usenumber()

		if stage != None:
			runtime.manager.stack_stage(stage)

	def yes_cb(self):
		runtime.manager.stack_stage(mmscomposestage.MMSMessageNotify(_('MMS Delete'), MMSboxdeleteNotify_cb))

	def no_cb(self):
		runtime.manager.back_stage()

	def back_activate_menu1(self):
		pass

	def back_activate_menu2(self):
		runtime.manager.back_stage()