import dspg
import time, ntptime, utils
import config
import status

from roxiadebug import *

class Dspg(dspg.Dspg):
	def __init__(self):
		dspg.Dspg.__init__(self)
		self.sending_dtmf = False
		self.dtmf_queue = ''
		self.generating_dtmf = False
		self.stopped = False
		self.stop_timer = 0
		self.sending_timer = 0
		self.last_dtmf = ''
		self.dtmf_sent_cb = None
		self.by_keydown = False
		self.queued_state = None

	def dtmf_sending_cb(self):
		if config.dtmf_debug:
			print 'dtmf sending cb: queue', self.dtmf_queue
		self.sending_timer = 0
		if self.dtmf_queue:
			dtmf = self.dtmf_queue[0]
			self.dtmf_queue = self.dtmf_queue[1:]
			if config.dtmf_debug:
				print 'dtmf send', dtmf[0]
			if not self.by_keydown or self.dtmf_queue:
				if dtmf[0] in ('A','B','C','D'):
					self.stop_timer = utils.Timer((int)(1000 * config.special_key_dtmf_duration), self.dtmf_stop_cb)
				else:
					self.stop_timer = utils.Timer(int(config.dtmf_duration * 1000), self.dtmf_stop_cb)
			self.dtmf_send(dtmf)
			self.generating_dtmf = True
			self.last_dtmf = dtmf
		return False

	def dtmf_end_cb(self):
		self.end_timer = 0
		self.sending_dtmf = 0
		self.dtmf_queue = ''
		self.dtmf_end()
		if self.queued_state:
			dspg.Dspg.set_state(self, self.queued_state)
			self.queued_state = None
		if self.dtmf_sent_cb:
			if config.dtmf_debug:
				print 'dtmf sending over:'
			self.dtmf_sent_cb()
			self.dtmf_sent_cb = None
	
	# eicho add. 06.02.12
	def send_dtmf_cont(self, dtmf, by_keydown):
		roxia_trace('dspg.send_dtmf(), key=', dtmf, 'by_keydown=', by_keydown)

		self.last_dtmf = dtmf[0]
		self.end_timer = 0
		self.by_keydown = by_keydown
		
		#print '====== eicho) start dtmf_start() ==='
		self.dtmf_start()
		self.sending_dtmf = True
		self.dtmf_sending_time = ntptime.ntime()
		self.dtmf_send(dtmf[0])
		#print '====== eicho) after dtmf_send/', dtmf[0]
		self.generating_dtmf = True	
		time.sleep(config.dtmf_duration)
		#print '====== eicho) after time.sleep/', config.dtmf_duration
		self.dtmf_stop()
		#print '====== eicho) after dtmf_stop'

		time.sleep(config.PSTN_after_R_interval)
		#print '====== eicho) after time.sleep(R_interval)/', config.PSTN_after_R_interval
		self.stop_timer = 0
		
		#print '====== eicho) start dtmf_start() ==='
		self.dtmf_start()
		self.dtmf_sending_time = ntptime.ntime()
		self.dtmf_send(dtmf[1])
		#print '====== eicho) afer dtmf_send/', dtmf[1]
		self.last_dtmf = dtmf[1]
		time.sleep(config.dtmf_duration)
		#print '====== eicho) after time.sleep/', config.dtmf_duration
		self.dtmf_stop()
		#print '====== eicho) safter dtmf_stop'
	
		self.end_timer = 0
		self.sending_dtmf = 0
		self.dtmf_queue = ''
		self.dtmf_end()
		#print '====== eicho) after dtmf_end()'
		if self.queued_state:
			dspg.Dspg.set_state(self, self.queued_state)
			#print '====== eicho) after dspg.set_state(queued_state)/',  self.queued_state
			self.queued_state = None
	# eicho end.

	def dtmf_stop_cb(self):
		if config.dtmf_debug:
			print 'dtmf stop cb: queue', self.dtmf_queue
		self.dtmf_stop()
		time.sleep(config.dtmf_pause)
		self.generating_dtmf = False
		self.stop_timer = 0
		if self.queued_state:
			self.dtmf_end()
			dspg.Dspg.set_state(self, self.queued_state)
			self.queued_state = None
			try:
				self.dtmf_start()
			except:
				if config.dtmf_debug:
					print 'EXCEPT) dtmf_stop_cb - Invalid state(x) in send dtmf'
				return False

		if self.dtmf_queue:
			self.sending_timer = utils.Idle(self.dtmf_sending_cb)
		else:
			self.end_timer = utils.Timer(200, self.dtmf_end_cb)

	def send_dtmf(self, dtmf, by_keydown):
		roxia_trace('dspg.send_dtmf(), key=', dtmf, 'by_keydown=', by_keydown)
		if dtmf.endswith('R'):
			status.hook_flash_status=1
		else:
			status.hook_flash_status=0

		if config.dtmf_debug:
			print 'dtmf:send_dtmf up', self.last_dtmf, dtmf, self.dtmf_queue
		self.end_timer = 0
		self.by_keydown = by_keydown

		if not self.sending_dtmf:
			self.dtmf_start()
			self.sending_dtmf = True

		if not self.dtmf_queue and not self.generating_dtmf:
			self.last_dtmf = dtmf[0]
			self.dtmf_sending_time = ntptime.ntime()
			if config.dtmf_debug:
				print 'dtmf send', dtmf[0]
			if not by_keydown:
				if dtmf[0] in ('A', 'B', 'C', 'D'):
					self.stop_timer = utils.Timer((int)(1000 * config.special_key_dtmf_duration), self.dtmf_stop_cb)
				else:
					self.stop_timer = utils.Timer((int)(1000 * config.dtmf_duration), self.dtmf_stop_cb)
			self.dtmf_send(dtmf[0])
			self.generating_dtmf = True
			self.dtmf_queue += dtmf[1:]
		else:
			self.dtmf_queue += dtmf

	def handle_up_key(self, key):
		roxia_event('dtmf.handle_up_key(), key=', key)
		if config.dtmf_debug:
			print 'dtmf:handle up', self.last_dtmf, key, self.dtmf_queue
		if self.last_dtmf == key and not self.dtmf_queue:
			self.last_dtmf = ''
			timeover = ntptime.ntime() - (self.dtmf_sending_time + config.dtmf_duration)
			if timeover > 0.0:
				self.dtmf_stop_cb()
			else:
				self.stop_timer = utils.Timer(-(int)(timeover * 1000), self.dtmf_stop_cb)
		self.by_keydown = False

	def dtmf_abort(self):
		if config.dtmf_debug:
			print 'dtmf abort'
		if self.sending_dtmf:
			self.dtmf_end()
		self.dtmf_queue = ''
		self.sending_dtmf = False
		self.stop_timer = 0
		self.sending_timer = 0
		self.end_timer = 0
		self.dtmf_sent_cb = 0
		self.generating_dtmf = 0

	def change_to_handset(self):
		roxia_event('dtmf.change_to_handset()')
		state = self.get_state()

		# eicho add 06.02.16
		if state == self.ST_IDLE:
			print 'DTMF:change_to_handset() invalid key - ST_IDLE.'
			return
		# eicho end.
		
		transition = {
			self.ST_SPK_OFFHK: self.ST_HS_OFFHK,
			self.ST_SPK_OFFHK_CONV: self.ST_HS_OFFHK_CONV,
			self.ST_SPK_OFFHK_LPLAY: self.ST_HS_OFFHK_LPLAY,
			self.ST_SPK_OFFHK_BPLAY: self.ST_HS_OFFHK_BPLAY,
			self.ST_SPK_OFFHK_RPLAY: self.ST_HS_OFFHK_RPLAY,
			self.ST_V_SPK_OFFHK: self.ST_V_HS_OFFHK,
			self.ST_V_SPK_OFFHK_LPLAY: self.ST_V_HS_OFFHK_LPLAY,
			self.ST_SPK_OFFHK_CONV_MUTE: self.ST_HS_OFFHK_CONV_MUTE,
			self.ST_V_SPK_OFFHK_MUTE: self.ST_V_HS_OFFHK_MUTE
			}
			
		# eicho modify 06.04.12
		try:
			new_state = transition[state]
			if config.audio_debug:
				print '**********change_to_handset:', state, 'to', new_state
		except:
			new_state = state
			if config.audio_debug:
				print '**********CAN NOT change to HS!! KEEP state:', state
			
		
		self.set_state(new_state)

	def change_to_spk(self):
		roxia_event('dtmf.change_to_spk()')
		state = self.get_state()
		transition = {
			self.ST_HS_OFFHK: self.ST_SPK_OFFHK,
			self.ST_HS_OFFHK_CONV: self.ST_SPK_OFFHK_CONV,
			self.ST_HS_OFFHK_LPLAY: self.ST_SPK_OFFHK_LPLAY,
			self.ST_HS_OFFHK_BPLAY: self.ST_SPK_OFFHK_BPLAY,
			self.ST_HS_OFFHK_RPLAY: self.ST_SPK_OFFHK_RPLAY,
			self.ST_V_HS_OFFHK: self.ST_V_SPK_OFFHK,
			self.ST_V_HS_OFFHK_LPLAY: self.ST_V_SPK_OFFHK_LPLAY,
			self.ST_HS_OFFHK_CONV_MUTE: self.ST_SPK_OFFHK_CONV_MUTE,
			self.ST_V_HS_OFFHK_MUTE: self.ST_V_SPK_OFFHK_MUTE,
			self.ST_V_SPK_OFFHK_LPLAY: self.ST_V_SPK_OFFHK_LPLAY
			}
		# eicho add 06.04.12
		try:
			new_state = transition[state]
			if config.audio_debug:
				print '**********change_to_spk:', state, 'to', new_state
		except:
			new_state = state
			if config.audio_debug:
				print '**********CAN NOT change to SPK!! KEEP state:', state
			
		# eicho end.
		self.set_state(new_state)

	def change_to_conv(self):
		import status
		if status.videocall_mode != status.VideoCallDisconnected:  # ip calls (including PSTN indirect video call)

			if status.modem_audio_state == status.SPK:
				self.set_state(self.ST_V_SPK_OFFHK)
			elif status.modem_audio_state == status.HS:
				self.set_state(self.ST_V_HS_OFFHK)
		else:
			import profile
			if profile.ip_mode == 0: # pstn
				if status.modem_audio_state == status.SPK:
					self.set_state(self.ST_SPK_OFFHK_CONV)
				elif status.modem_audio_state == status.HS:
					self.set_state(self.ST_HS_OFFHK_CONV)
			else: # ip
				if status.modem_audio_state == status.SPK:
					self.set_state(self.ST_V_SPK_OFFHK)
				elif status.modem_audio_state == status.HS:
					self.set_state(self.ST_V_HS_OFFHK)
				# HS_SPK not in use

	def audio_mute(self, mute):
		state = self.get_state()
		if config.audio_debug:
			print 'Dspg:audio_mute, mute:', mute
			print 'Dspg:audio_mute, orig state:', state
				
		if mute:
			#eicho modify state. (add self.ST_HS_OFFHK)
			if state in (self.ST_HS_OFFHK_CONV, self.ST_HS_OFFHK_BPLAY, self.ST_HS_OFFHK):
				state = self.ST_HS_OFFHK_CONV_MUTE
			elif state in (self.ST_SPK_OFFHK_CONV, self.ST_SPK_OFFHK_BPLAY):
				state = self.ST_SPK_OFFHK_CONV_MUTE
			# vpark begin 06.02.08
			elif state in (self.ST_V_HS_OFFHK, self.ST_V_HS_OFFHK_LPLAY):
				state = self.ST_V_HS_OFFHK_MUTE
			elif state in (self.ST_V_SPK_OFFHK, self.ST_V_SPK_OFFHK_LPLAY):
				state = self.ST_V_SPK_OFFHK_MUTE
			# vpark end 06.02.08
		else:
			if state == self.ST_HS_OFFHK_CONV_MUTE:
				state = self.ST_HS_OFFHK_CONV
			elif state == self.ST_SPK_OFFHK_CONV_MUTE:
				state = self.ST_SPK_OFFHK_CONV
			# vpark begin 06.02.08
			elif state == self.ST_V_HS_OFFHK_MUTE:
				state = self.ST_V_HS_OFFHK
			elif state == self.ST_V_SPK_OFFHK_MUTE:
				state = self.ST_V_SPK_OFFHK
			# vpark end 06.02.08
		if config.audio_debug:
			print 'Dspg:audio_mute, changed state:', state
		self.set_state(state)

#ka...3800 codec 2007.04.26
	def set_codec(self, a_payload):
		if a_payload:
			if a_payload == 96 or a_payload == 9: #AMR-WB & G722
				status.wideband_codec = 1 #True
#				dspg.Dspg.set_wideband(self, 1)
			else:
				status.wideband_codec = 0 #False

	def reset_codec(self):
		import status
		status.wideband_codec = 0
		dspg.Dspg.set_wideband(self, 0)

	def default_set_volume(self):
		# default volume settings
		from setting import setting
		self.set_state(self.ST_IDLE)
		self.set_state(self.ST_V_HS_OFFHK_LPLAY)
		self.set_volume(setting.handset_volume)
		self.set_state(self.ST_V_SPK_OFFHK_LPLAY)
		self.set_volume(setting.speaker_volume)
		self.set_state(self.ST_IDLE)

		
	def set_state(self, state):
		roxia_event('@@@@@ dtmf.set_state(), stage=', state)
		from setting import setting
		# hcryoo : [20070413_1]
		if state in (self.ST_V_SPK_OFFHK, \
			self.ST_SPK_OFFHK_CONV_MUTE, \
			self.ST_V_SPK_OFFHK_MUTE):

			if config.AEC_debug:
				if config.roxia_event:
					print '************>>>>>> SET AEC 1'
				import runtime
				runtime.vdci_send_mesg(code1=config.MESG_SET_PARAMS, code2=config.MESG_SET_AEC, mesg1=1)
			else:
				if config.roxia_event:
					print '************>>>>>> SET AEC 0'
				import runtime
				runtime.vdci_send_mesg(code1=config.MESG_SET_PARAMS, code2=config.MESG_SET_AEC, mesg1=0)
#ka...3800 sw volume을 AEC set 마다 해준다. 2007.05.21
			if config.roxia_event:
				print '************>>>>>> S/W volume set -Speaker'
			#EPTBR_DEV_HANDSFREE_SPK/*0x04*/ | EPTBR_DEV_HANDSET_MIC  = 0x08
			#ka...3800 2007.05.21  SPK만 내려준다.
			device_number = 12
			runtime.vdci_send_mesg(code1=config.MESG_SET_PARAMS, code2=config.MESG_SW_VOLUME, mesg1=device_number, mesg2=setting.speaker_volume)

		
			import os
			if status.wideband_codec == 1:
				if config.roxia_event:
					print '************>>>>>> EXECUTE equalizer in SPK WB'
				os.system('equalizer write /usr/etc/wb_hf_coeff.txt')
			else:
				if config.roxia_event:
					print '************>>>>>> EXECUTE equalizer in SPK NB'
				os.system('equalizer write /usr/etc/nb_hf_coeff.txt')

		elif state in (self.ST_V_HS_OFFHK, \
			self.ST_HS_OFFHK_CONV_MUTE, \
			self.ST_V_HS_OFFHK_MUTE):

			if config.roxia_event:
				print '************>>>>>> SET AEC 0'
			import runtime
			runtime.vdci_send_mesg(code1=config.MESG_SET_PARAMS, code2=config.MESG_SET_AEC, mesg1=0)

#ka...3800 sw volume을 AEC set 마다 해준다. 2007.05.21
			if config.roxia_event:
				print '************>>>>>> S/W volume set - Handset'
			#EPTBR_DEV_HANDSET_SPK/*0x01*/|EPTBR_DEV_HANDSFREE_MIC = 0x02
			#ka...3800 2007.05.21  SPK만 내려준다.
			device_number = 3
			runtime.vdci_send_mesg(code1=config.MESG_SET_PARAMS, code2=config.MESG_SW_VOLUME, mesg1=device_number, mesg2=setting.handset_volume)

			
			import os
			if status.wideband_codec == 1:
				if config.roxia_event:
					print '************>>>>>> EXECUTE equalizer in HS WB'
				os.system('equalizer write /usr/etc/wb_hs_coeff.txt')
			else:
				if config.roxia_event:
					print '************>>>>>> EXECUTE equalizer in HS NB'
				os.system('equalizer write /usr/etc/nb_hs_coeff.txt')

			
		if self.sending_dtmf:
			self.queued_state = state
			return
		#ka...3800 codec 2007.04.26 wideband codec 일 경우, set_state전에  wideband값을 명시해 준다.
		if status.wideband_codec == 1:
			dspg.Dspg.set_wideband(self, 1)
		dspg.Dspg.set_state(self, state)