# -*- coding: utf-8 -*-

import time, os, signal, config
import basemodel, phonesetting
import baseui
import uiconfig, config, status, utils, profile, manager
import runtime
from basemodel import Stage, EntryStage, NotifyStage, GaugeStage, ListStage, YesNoStage
from setting import setting

from model import IdleStage
from roxiadebug import *
import newprof
import errorcode

##################################
#start hyshim 2007.01.09 : utf-8 -> euc-kr
def euckr2utf8(message):
	try:
	 	result = ''
		result = unicode(message,'euc-kr').encode('utf-8')
		return result
	except:
		print 'euckr2utf8 error'
		return message
def utf82euckr(message):
	try:
	 	result = ''
		result = unicode(message,'utf-8').encode('euc-kr')
		return result
	except:
		print 'utf82euckr error'
		return message

#end

def wlAvailable():
	if len(os.popen('lsmod | grep wl').read()) > 0:
		return True
	return False
	
##################################
# moved to errorcode.py
##################################
#
#msg_D101_init = '처음으로 본체가 사용준비 중입니다.\n잠시만 기다려 주세요.'
#msg_D101 = '본체가 사용준비 중입니다.\n잠시만 기다려 주세요.'
#msg_M101 = '랜선 연결을 확인해 주세요.'
#msg_M102 = '네트워크에 연결 중입니다.\n잠시만 기다려 주세요.'
#msg_M301 = 'DHCP IP 할당을 받을 수 없습니다.'
#msg_M302 = '고정 IP 설정을 확인해 주세요.'
#msg_M901 = '일시적인 네트워크 장애입니다.'
#msg_W100 = '"%s"에 접속 중입니다.'
#msg_W100_mega = 'KT전용 AP에 접속 중입니다.'
#msg_W101 = '"%s" 접속에 실패하였습니다.\n재시도하려면 통화버튼을 누르세요.'
#msg_W101_1 = 'KT전용 AP접속에 실패하였습니다.\n재시도하려면 통화버튼을 누르세요.'
#msg_W101_mega = '"%s"에 접속할 수 없습니다. KT전용 AP에 접속 하시겠습니까?'
#msg_W101_gen = 'KT전용 AP에 접속할 수 없습니다.\n보조프로파일에 접속 하시겠습니까?'
#msg_W101_scan = '"%s"에 접속할 수 없습니다.\n무선랜 검색을 하시겠습니까?'
#msg_W102 = '무선 보안키 적용에 실패하였습니다.\n재시도하려면 통화버튼을 누르세요.'
#msg_W103 = 'IP를 요청 중입니다.'
#msg_W104 = 'DHCP 설정에 실패하였습니다.\n재시도하려면 통화버튼을 누르세요.'
#msg_W105 = '고정 IP 설정을 확인해 주세요.\n재시도하려면 통화버튼을 누르세요.'
#msg_W106 = '일시적인 네트워크 장애입니다.\n재시도하려면 통화버튼을 누르세요'
#msg_W107 = 'IP 설정상태를 확인해 주세요.\n재시도하려면 통화버튼을 누르세요.'
#msg_W108 = '"%s"에 접속 되었습니다'
#msg_W108_mega = 'KT전용 AP에 접속 되었습니다'
#msg_W109 = '무선 네트워크가 끊어졌습니다.\n무선 네트워크를 검색 중입니다.'
#msg_W110 = '네트워크 장애로 서버와의 연결이\n끊어졌습니다. 재연결을 시도합니다.'
#msg_SR403 = '서버에 등록할 수 없습니다.'
#msg_SR404 = '인터넷 전화번호를 확인해 주세요.'
#msg_SR480 = '서버에 등록할 수 없습니다.\n재시도하려면 통화버튼을 누르세요.'
#
##################################
def isInitialBoot():
	if not os.access("/usr/etc/first_boot_done", os.F_OK):
		debugLogN('INITIAL BOOT : TRUE')
		cmd = 'touch /usr/etc/first_boot_done'
		os.system(cmd)
		return True
	debugLogN('INITIAL BOOT : FALSE')		
	return False

def isTestMode():
	if os.access("/usr/etc/testmode1", os.F_OK) \
			or os.access("/usr/etc/testmode2", os.F_OK)  \
			or os.access("/usr/etc/testmode3", os.F_OK): 
		debugLogC('TEST_MODE : TRUE')
		return True
	return False


class InitConfNotifyStage(NotifyStage):
	domonitor_forbidden = True
	def __init__(self, message,noexit=False,duration=0,cb=None, exit_cb=None):
		self.cur_profile = profile.profile.get_profile()
		self.noexit = noexit
		self.exit_cb = exit_cb
		if self.cur_profile == 1:	# if LAN:
			self.icon = uiconfig.baloon_setting_system_network_icon
		else:
			self.icon = uiconfig.baloon_setting_system_network_wireless_icon
		NotifyStage.__init__(self, message, self.icon, cb, duration)
		if not self.noexit:
			#self.ui.set_menu4(_('CANCEL'))
			if setting.lang == 'Korean':
				self.ui.set_menu4(uiconfig.WD_0062)			
			elif setting.lang == 'Norwegian':	
				self.ui.set_menu4('AVBRYT')		
			else:
				self.ui.set_menu4('CANCEL')
			
		self.ui.show_bg=True
		
	def handle_key(self,key):
		if self.noexit:
			if key in (config.Red, config.Green, config.OffHook, config.OnHook):
				print 'Ignore key(1) - ', key
				return True

		else:
			# exit key is available...
			if key in (config.Menu4, config.Red): # Exit
				if self.exit_cb:
					self.exit_cb()
					return True
				runtime.manager.back_stage()
				return True
			elif key in (config.Green, config.OffHook, config.OnHook, config.Video):
				print '** Ignore key(2) - ', key
				return True

		NotifyStage.handle_key(self,key)

class ReInitIpNetworks(InitConfNotifyStage):
	domonitor_forbidden = True
	def __init__(self):
		message = errorcode.msg_D101
		#errorcode.set_idle_errmsg(message, 'D101')
		InitConfNotifyStage.__init__(self, message, noexit=True, duration =10000, cb=self.next_cb)
		os.system('eth0_stop')
		os.system('wlstop')
		status.LanConnected == False
		runtime.manager.vdci_deregister_kill()
		status.set_regstatus(0)
		debugLogN('ReInitIpNetworks.__init__ ')
	def next_cb(self):
		runtime.manager.change_stage(InitIpNetworks)


class InitIpNetworks(InitConfNotifyStage):
	name = 'init ipnetwork'
	domonitor_forbidden = True
	def __init__(self):
		debugLogN('InitIpNetworks.__init__ start') 
		if isTestMode():
			InitConfNotifyStage.__init__(self, 'test_mode', noexit=True, duration =1000, cb=self.back_cb)
			return

		try:
			runtime.manager.wifi_auth_notified = 0
		except:
			pass
		self.initboot=  isInitialBoot()
		self.lanstat = runtime.peek_lanlink()

		message = 'Initializing IP network...'

		if self.initboot:
			if setting.lang == 'English':
				message = 'Initializing IP network for the first time'
			elif setting.lang == 'Norwegian':
				message = 'Forbereder f\xC3\xB8rste oppstart.\nVennligst vent.'
			else: # setting.lang == 'Korean':
				#message = '처음으로 네트워크를 초기화 합니다.'
				#message = unicode(message,'euc-kr').encode('utf-8')
				message = errorcode.msg_D101_init
				#errorcode.set_idle_errmsg(message, 'D101')
		else:
			if setting.lang == 'English':
				message = 'Initializing IP network...'
			elif setting.lang == 'Turkish':
				# TODO: add /x code
				#message = 'IP a\xC4\x9Eyeniden ba\xC5\x9Elatılıyor...'
				message = 'IP a\xC4\x9Fyeniden ba\xC5\x9Flatılıyor...'
			elif setting.lang == 'Francais':
				message = 'Initialisation du r\xC3\xA9seau IP...'
			elif setting.lang == 'Spain':
				message = 'IniciaIizando red IP...'
# ka...lang add 07.01.15		
			elif setting.lang == 'Deutsch':
				message = 'IP-Netzwerk initialisieren...'
			elif setting.lang == 'Portuguese':
				message = 'Inicializando rede IP...'
			elif setting.lang == 'Norwegian':	
				message = 'Initialiserer IP-nettverk...'
			elif setting.lang == 'Korean':
				#message = '네트워크를 초기화 합니다'	
				#message = unicode(message,'euc-kr').encode('utf-8')
				message = errorcode.msg_D101
				#errorcode.set_idle_errmsg(message, 'D101')
				
		InitConfNotifyStage.__init__(self, message, noexit=True, duration = 10*60*1000, cb=self.back_cb)
		if self.initboot:
			self.connTimer = runtime.evas.idle_add(self.init_boot)
		else:
			self.connTimer = runtime.evas.idle_add(self.normal_boot)
		self.once_timer = None
		self.link_timer = None

#MMW	2008.0622	network error message to dect
		utils.send_VP_net_status_to_DCT('D101')
#end of MMW		
		self.init_state()
		debugLogN('InitIpNetworks.__init__ end: initboot(%d), lanstat(%d) gen_mac(%s) mega_mac(%s)'%(self.initboot, self.lanstat, profile.wifi_profile_general.mac_mode_on, profile.wifi_profile_kt_default.mac_mode_on))	

	def change_message(self, message):
		if self.ui:
			self.ui.change_message(message)
			if runtime.manager.stage.name != 'init ipnetwork':
				self.ui.hide()
			
	def init_state(self):
		self.gen_try_mac_mode = False
		if profile.wifi_profile_general.mac_mode_on == 'yes':
			self.gen_try_mac_mode = True	
		self.gen_force_non_mac_mode = False

		self.mega_try_mac_mode = False
		if profile.wifi_profile_kt_default.mac_mode_on == 'yes':
			self.mega_try_mac_mode = True	
		self.mega_force_non_mac_mode = False

		
	def destroy(self):
		debugLogN('InitIpNetworks.destroy')

		self.toTimer = None
		self.connTimer = None
		self.mmiTimer = None
		NotifyStage.destroy(self)

	def send_linkup(self):
		# LAN+Static case, should send link up to manager.
		try:
			debugLogC("initconf.py: send_link up")
			runtime.manager.handle_key(True, config.key_link_up)
			return False
		except:
			debugLogC("send_link up error, try again")
			return True
		
	def normal_boot(self):
		# start profile.
		debugLogN('InitIpNetworks.normal_boot ')	
		if profile.profile.get_profile() == 1:
			# if lan profile...
			phonesetting.cur_profile = profile.lan_profile
			if runtime.peek_lanlink():
				pass
				#debugLogN('INIT : send eth link up')
				#self.link_timer = utils.Timer(200, self.send_linkup)
			else:
			
				#runtime.manager.change_stage(NotifyStage(_('check lan connection'),  uiconfig.baloon_setting_system_network_icon))
				message = errorcode.msg_M101
				errorcode.set_idle_errmsg(message, 'M101')	
				runtime.manager.change_stage(NotifyStage(message, uiconfig.baloon_setting_system_network_icon))
#MMW	2008.0622	network error message to dect
				utils.send_VP_net_status_to_DCT('M101')
#end of MMW
		else:
			phonesetting.cur_profile = profile.wifi_profile
			if not wlAvailable():
				#os.system('wlstart')
				#cmd =  'ifconfig wlan0 down'
				#os.system(cmd)
				cmd = 'wifi_driver_loading'
				os.system(cmd)
			debugLogN('INIT : load wifi driver megaAPEnabled(%d)'%setting.megaAPEnabled)
			if setting.megaAPEnabled:
				# wlstart
				# time out set.
				self.mmiTimer = utils.Timer(config.mega_mmi_timeout, self.mega_mmi_timeout_cb)
				self.connTimer = utils.Timer(config.a_moment, self.start_mega_ap_conn,False)
			else:
				
				if len(profile.wifi_profile_general.essid) > 0:
					# if gen profile is available...
					self.mmiTimer = utils.Timer(config.gen_mmi_timeout, self.gen_mmi_timeout_cb)
					self.connTimer = utils.Timer(config.a_moment, self.start_gen_ap_conn,False)	
				else:
					# scan
					stage = newprof.WirelessScanWaitStage
					runtime.manager.change_stage(stage)

	def init_boot(self):
		# start profile.
		# shchun : KT requested LAN as factory default
		#	service center claimed auto selection is confusing...
		debugLogN('InitIpNetworks.init_boot: LAN enabled as factory default')	

		profile.profile.set_profile(1) # LAN profile.
		phonesetting.cur_profile = profile.lan_profile
		
		if runtime.peek_lanlink():
			pass
			#debugLogN('INIT : send eth link up')
			#runtime.manager.handle_key(True, config.key_link_up)
		else:
			message = errorcode.msg_M101
			errorcode.set_idle_errmsg(message, 'M101')	
			runtime.manager.change_stage(NotifyStage(message, uiconfig.baloon_setting_system_network_icon))
#MMW	2008.0622	network error message to dect
			utils.send_VP_net_status_to_DCT('M101')
#end of MMW

		
#		if self.lanstat: # if eth is up
#			profile.profile.set_profile(1) # LAN profile.
#			phonesetting.cur_profile = profile.lan_profile
#			
#			debugLogN('INIT : start eth profile, sending link up')
#			runtime.manager.handle_key(True, config.key_link_up)
#		else:
#			profile.profile.set_profile(2) # wifi profile.
#			phonesetting.cur_profile = profile.wifi_profile
#			if not wlAvailable():
#				cmd = 'wifi_driver_loading'
#				os.system(cmd)			
#
#			debugLogN('INIT : load wifi driver')
#			self.connTimer = utils.Timer(config.a_moment, self.start_mega_ap_conn, False)
#			self.mmiTimer = utils.Timer(config.mega_mmi_timeout, self.first_mega_mmi_timeout_cb)
			
	def start_mega_ap_conn(self, once=False):
		debugLogN('start_mega: wlstart() once(%d)'%once)	
		activateMegaApCfg()

		message=errorcode.msg_W101_1 # same with M301
		errorcode.set_idle_errmsg(message, 'W101')

		os.system('wlstart &')	
#MMW	2008.0622	network error message to dect
		utils.send_VP_net_status_to_DCT('W100')
#end of MMW	
		self.connTimer = utils.Timer(config.a_moment, self.mega_ap_conn, once)

		if once:
			self.once_timer = utils.Timer(config.resume_network_timeout_wifi, self.conn_timeout_cb)
		#self.onceTimer 
		
	def start_gen_ap_conn(self, once=False):
		debugLogN('start_gen: wlstart() once(%d)'%once)

		message=errorcode.msg_W101 %profile.wifi_profile_general.essid
		errorcode.set_idle_errmsg(message, 'W101')
		

		deactivateMegaApCfg()

		os.system('wlstart &')

#MMW	2008.0622	network error message to dect
		utils.send_VP_net_status_to_DCT('W100')
#end of MMW			

		self.connTimer = utils.Timer(config.a_moment, self.gen_ap_conn, once)
		if once:
			self.once_timer = utils.Timer(config.resume_network_timeout_wifi, self.conn_timeout_cb)
	
	def mega_ap_conn(self, once):
		# mega ap conn worker ..
		#message=errorcode.msg_W100%'Mega AP'
		message=errorcode.msg_W100_mega
		#errorcode.set_idle_errmsg(message, 'W100')
		
	
		self.change_message(message)
		debugLogN('TRY : mega_conn TO(%d) sec, mega_mac_mode(%d/%d), once(%d)'%(config.mega_ap_timeout/1000, self.mega_try_mac_mode, self.mega_force_non_mac_mode, once))
			
#		activateMegaApCfg()
		if self.mega_try_mac_mode and self.mega_force_non_mac_mode:
			disableMegaMacMode()

		#import utils
		self.toTimer = utils.Timer(config.mega_ap_timeout, self.mega_ap_timeout_cb)
		
	def mega_ap_timeout_cb(self):

		debugLogN('mega_TO_cb() mega_mac_mode(%d/%d)'%(self.mega_try_mac_mode, self.mega_force_non_mac_mode))

		if self.mega_try_mac_mode == True and self.mega_force_non_mac_mode == False:
			self.mega_force_non_mac_mode = True
			self.connTimer = runtime.evas.idle_add(self.mega_ap_conn, False)
			return
		elif self.gen_try_mac_mode == True and self.mega_force_non_mac_mode == True:
			pass
			#enableMegaMacMode()

		self.connTimer = runtime.evas.idle_add(self.mega_ap_conn, False)
		self.init_state()

	def first_mega_mmi_timeout_cb(self):
		debugLogN('first_mega_mmi_timeout_cb()')
		
		stage = runtime.manager.find_stage('init ipnetwork', True)
		if not stage:
			print 'no init ipnetwork stage, just return'
			return 

		stage = AskToProceedConfigStage
		runtime.manager.stack_stage(stage)
			
	def mega_mmi_timeout_cb(self):
		debugLogN('mega_mmi_timeout_cb()')
		
		stage = runtime.manager.find_stage('init ipnetwork', True)
		if not stage:
			print 'no init ipnetwork stage, just return'
			return 

		if len(profile.wifi_profile_general.essid) > 0:# if exists gen profile.
			if self.isGenApAvailable():# if exists kt profile.
				stage = AskToProceedGenProfStage
				runtime.manager.stack_stage(stage)
			else:
				# do nothing
				runtime.manager.change_stage(IdleStage, True)

		else:
			stage = AskToProceedConfigStage
			runtime.manager.stack_stage(stage)
			
	def gen_mmi_timeout_cb(self):
		debugLogN('gen_mmi_timeout_cb()')
	
		stage = runtime.manager.find_stage('init ipnetwork', True)
		if not stage:
			print 'no init ipnetwork stage, just return'
			return 

		#stage = AskToProceedMegaProfStage(profile.wifi_profile_general.essid)
		#runtime.manager.stack_stage(stage)

		if config.KT_profile_enable == True :	#KT
			if self.isktApAvailable():# if exists kt profile.
				stage = AskToProceedMegaProfStage(profile.wifi_profile_general.essid)
				runtime.manager.stack_stage(stage)
			else:
				# do nothing
				runtime.manager.change_stage(IdleStage, True)
		else :
			runtime.manager.change_stage(IdleStage, True)
			

	
	def isktApAvailable(self):
		# purpose: to check air if kt ap is existing...
		os.system('wlscan_kt_AP')
		#time.sleep(1)

		os.system('cat /tmp/wifiscan_kt_AP.tmp')
		result = len(open('/tmp/wifiscan_kt_AP.tmp').read())
		debugLogN('isktApAvailable RESULT(%d)'% result)
		if result > 0:
			return True
		return False

	def isGenApAvailable(self):
		# purpose: to check air if gen ap is existing...
		os.system('wlscan_general_AP')
		#time.sleep(1)

		os.system('cat /tmp/wifiscan_general_AP.tmp')
		result = len(open('/tmp/wifiscan_general_AP.tmp').read())
		debugLogN('isGenApAvailable RESULT(%d)'% result)
		if result > 0:
			return True
		return False
				
	def gen_ap_conn(self, once=False):
		# for first boot: try to connect mega ap.
		
		message=errorcode.msg_W100%profile.wifi_profile_general.essid
		#errorcode.set_idle_errmsg(message, 'W100')
		self.change_message(message)
		debugLogN('TRY : custom ap conn Timeout(%d) sec, mac_mode(%d/%d) once(%d)'%(config.gen_ap_timeout/1000, self.gen_try_mac_mode, self.gen_force_non_mac_mode, once))
#		deactivateMegaApCfg()
		if self.gen_try_mac_mode and self.gen_force_non_mac_mode:
			disableGenMacMode()
	
		#import utils
		self.toTimer = utils.Timer(config.gen_ap_timeout, self.gen_ap_timeout_cb)

	def gen_ap_timeout_cb(self):
		debugLogN('gen_ap_timeout_cb() mac_mode(%d/%d)'%(self.gen_try_mac_mode, self.gen_force_non_mac_mode))
		#os.system('wlstop')

		if self.gen_try_mac_mode == True and self.gen_force_non_mac_mode == False:
			self.gen_force_non_mac_mode = True
			self.connTimer = runtime.evas.idle_add(self.gen_ap_conn)
			return
		elif self.gen_try_mac_mode == True and self.gen_force_non_mac_mode == True:
			#enableGenMacMode()
			pass

		self.connTimer = runtime.evas.idle_add(self.gen_ap_conn)
		self.init_state()

	def dhcp_start(self):
		debugLogN('initconf.dhcp_start(): called')
		if profile.profile.get_profile() == 1:
			os.system('eth0_start&')
			self.toTimer = utils.Timer(config.dhcp_timeout_lan, self.dhcp_timeout_cb)
			message=errorcode.msg_M102 # same with M301
		else:
			os.system('wifi_dhcp&')
			self.toTimer = utils.Timer(config.dhcp_timeout_wifi, self.dhcp_timeout_cb)
			message=errorcode.msg_W103 # same with M301
		self.change_message(message)
		debugLogN('dhcp start')
		self.once_timer = None
		runtime.manager.linkmonitor.restart_net_monitor()
		# ka...2008.06.24: dhcp start만 시킨다. result값은 IP_CHANGE로 확인		
		#message=errorcode.msg_W104 # same with M301
		#errorcode.set_idle_errmsg(message, 'W104')
		

	def dhcp_success(self):
		message=errorcode.msg_SR103 # same with M301
		self.change_message(message)
		self.toTimer = None
		self.connTimer = None # shchun add
		debugLogN('dhcp success')
		#errorcode.set_idle_errmsg('')

		if status.get_regstatus() == 0:
			message=errorcode.msg_SR103 # same with M301
			errorcode.set_idle_errmsg(message, refresh=True)
		else:
			errorcode.set_idle_errmsg('', delay_msec=2000, refresh=False)
		
		self.toTimer = utils.Timer(10*1000, self.back_cb)
		

	def link_up(self):
		self.toTimer = None
		debugLogN('InitIpNetworks.link up')
		#errorcode.set_idle_errmsg('')
		errorcode.set_idle_errmsg('', delay_msec=2000, refresh=False)


		
	def dhcp_timeout_cb(self):
		debugLogN('InitIpNetworks.dhcp timeout')

		if profile.profile.get_profile() == 1: # LAN
			if not runtime.peek_lanlink():
				debugLogN('skip: DHCP timeout initconf : eth link down')
				return
				
		#self.toTimer = utils.Timer(config.dhcp_timeout, self.dhcp_timeout_cb_2)

		message=errorcode.msg_W104 # same with M301
		errorcode.set_idle_errmsg(message, 'W104')
#MMW	2008.0622	network error message to dect
		utils.send_VP_net_status_to_DCT('W104')
		
		runtime.manager.linkmonitor.update_idlemsg()
#end of MMW			

		runtime.manager.linkmonitor.restart_net_monitor()
		runtime.manager.back_stage()
		#self.change_message(message)
		
	def dhcp_timeout_cb_2(self):
		#self.toTimer = utils.Timer(config.dhcp_interval, self.dhcp_start)
		
		runtime.manager.linkmonitor.restart_net_monitor()
		runtime.manager.back_stage()
		
	def conn_timeout_cb(self):
		debugLogN('ResumeInit.conn_timeout_cb')
		stage = runtime.manager.find_stage('init ipnetwork', True)
		stage2 = runtime.manager.find_stage('reinit ipnetwork', True)
		
		if not (stage or stage2):
			print 'no init ipnetwork stage, just return'
			return 
		if profile.profile.get_profile() == 1:
			pass

		else:
			if profile.wifi_profile._name == 'MegaAP':
				message=errorcode.msg_W101_1 # same with M301
				errorcode.set_idle_errmsg(message, 'W101')
			else:
				message=errorcode.msg_W101 %profile.wifi_profile_general.essid
				errorcode.set_idle_errmsg(message, 'W101')
			self.change_message(message)
			
		self.toTimer = utils.Timer(3000, self.conn_timeout_cb2)
	
	def conn_timeout_cb2(self):
		debugLogN('resume_network')
		runtime.manager.back_stage()
#MMW	2008.0622	network error message to dect
		if profile.profile.get_profile() == 1:
			pass
		else :
			if status.get_regstatus() == 0 :
				utils.send_VP_net_status_to_DCT('W101')
#end of MMW		
		pass
		
	def back_cb(self):
		debugLogN('InitIpNetworks.back_cb')
		runtime.manager.back_stage()
		
	def handle_key(self,key):
		debugLogN('InitIpNetworks.handle_key(%s)'%key)
		#if not self.noexit and key in (config.Menu4, config.Red): # Exit
		#	if profile.profile.get_profile() == 2:
		#		if profile.wifi_profile._name == 'MegaAP':
		#			message=errorcode.msg_W101_1 # same with M301
		#			errorcode.set_idle_errmsg(message, 'W101')
		#		else:
		#			message=errorcode.msg_W101 %profile.wifi_profile_general.essid
		#			errorcode.set_idle_errmsg(message, 'W101')
				
		return InitConfNotifyStage.handle_key(self,key)

#
# *shchun comment : dummy stages (ResumeInitDummy, AutoRegisteringStageDummy.)
#	In order to prevent frequent recovery routine run, when user hit Green key. 
#	If there is background recovery run(busy flag set, 10 sec term) 
#	The frame work delay foreground Green key recovery about 10 sec.
#	Meanwhile the phone tries to trick user as if recovery routine is running with Dummy stages.
#
#	While if foreground Green key recovery is running, background recovery will skip then trigger 1 min later. 
#
class ResumeInitDummy(InitIpNetworks):
	domonitor_forbidden = True
	name = 'reinit ipnetwork dummy'
	def __init__(self):
		debugLogN('ResumeInitDummy.__init__ ')	
		message = errorcode.msg_M102 
		InitConfNotifyStage.__init__(self, message, noexit=False, duration = config.net_monitor_cooling_time + 2000, cb=self.back_cb)

class AutoRegisteringStageDummy(InitIpNetworks):
	domonitor_forbidden = True
	name = 'auto registering dummy'
	def __init__(self):
		debugLogN('AutoRegisteringStageDummy.__init__ ')	
		message = _('Registering.')+'\n'+_('Please wait for a moment.')
		InitConfNotifyStage.__init__(self, message, noexit=False, duration = config.net_monitor_cooling_time + 2000, cb=self.back_cb)

class ResumeInit(InitIpNetworks):
	# when user hit the call button while network link is na.
	name = 'reinit ipnetwork'
	domonitor_forbidden = True
	def __init__(self):
		if isTestMode():
			InitConfNotifyStage.__init__(self, 'test_mode', noexit=True, duration =1000, cb=self.back_cb)
			return
		try:
			runtime.manager.wifi_auth_notified = 0
		except:
			pass
		if profile.profile.get_profile() == 1:
			message = errorcode.msg_M102 
			#errorcode.set_idle_errmsg(message, 'M102')
#MMW	2008.0622	network error message to dect
			utils.send_VP_net_status_to_DCT('M102')
#end of MMW			
			debugLogN('ResumeInit.__init__ WIRED mac_mode')	
		else:
#			if profile.wifi_profile._name == 'MegaAP':
			if setting.megaAPEnabled:
				message =errorcode.msg_W100_mega  
				#errorcode.set_idle_errmsg(message, 'W100')
				debugLogN('ResumeInit.__init__ WIRELESS/MEGA mac_mode gen/mega(%s/%s)'%( profile.wifi_profile_general.mac_mode_on, profile.wifi_profile_kt_default.mac_mode_on))	

			else:
				message =errorcode.msg_W100 %profile.wifi_profile_general.essid
				#errorcode.set_idle_errmsg(message, 'W100')
				debugLogN('ResumeInit.__init__ WIRELESS/GEN mac_mode gen/mega(%s/%s)'%( profile.wifi_profile_general.mac_mode_on, profile.wifi_profile_kt_default.mac_mode_on))	

		InitConfNotifyStage.__init__(self, message, noexit=False, duration = config.resume_network_mmi_timeout, cb=self.back_cb)
		self.post_timer = utils.Timer(config.a_moment, self.post_init)
		self.once_timer = None
		
	def post_init(self):
		if profile.profile.get_profile() == 1:

			# if lan profile...
			phonesetting.cur_profile = profile.lan_profile
			if runtime.peek_lanlink():
				debugLogN('INIT : send eth link up')
				runtime.manager.handle_key(True, config.key_link_up)
			else:
				#runtime.manager.change_stage(NotifyStage(_('check lan connection'),  uiconfig.baloon_setting_system_network_icon))

				message = errorcode.msg_M101
				#errorcode.set_idle_errmsg(message, 'M101')
				
				runtime.manager.change_stage(NotifyStage(message,  uiconfig.baloon_setting_system_network_icon))
#MMW	2008.0622	network error message to dect
				utils.send_VP_net_status_to_DCT('M101')
				
#end of MMW				
			self.once_timer = utils.Timer(config.resume_network_timeout_lan, self.conn_timeout_cb)

		else:
			phonesetting.cur_profile = profile.wifi_profile

			if not wlAvailable():
				#os.system('wlstart')
				#cmd =  'ifconfig wlan0 down'
				#os.system(cmd)
				cmd = 'wifi_driver_loading'
				os.system(cmd)	
				
			#if profile.wifi_profile._name == 'MegaAP':
			if setting.megaAPEnabled:
				self.connTimer = utils.Timer(config.a_moment, self.start_mega_ap_conn,True)
			else:
				self.connTimer = utils.Timer(config.a_moment, self.start_gen_ap_conn,True)
				
			self.once_timer = utils.Timer(config.resume_network_timeout_wifi, self.conn_timeout_cb)
					
			self.init_state()

	def change_message(self, message):
		if self.ui:
			self.ui.change_message(message)
			if runtime.manager.stage.name != 'reinit ipnetwork':
				self.ui.hide()
				

	
class AskToProceedMegaProfStage(YesNoStage):
	domonitor_forbidden = True
	# gen --> mega
	def __init__(self, name):
		message=errorcode.msg_W101_mega%name
		YesNoStage.__init__(self, message, self.yes_cb, self.no_cb, '', uiconfig.baloon_phone_setting_icon)

	def yes_cb(self):
 		setting.megaAPEnabled = 1
 		setting._save()
 		
		stage = runtime.manager.find_stage('init ipnetwork', True)
		if stage:
			message=errorcode.msg_Wait
			stage.change_message(message)
			
			stage.start_mega_ap_conn(True)
			runtime.manager.back_stage()
		
	def no_cb(self):
		#runtime.manager.back_stage()
		message=errorcode.msg_W101 %profile.wifi_profile_general.essid
		errorcode.set_idle_errmsg(message, 'W101')
		runtime.manager.change_stage(IdleStage, True)
#MMW	2008.0622	network error message to dect
		utils.send_VP_net_status_to_DCT('W101')
#end of MMW	

class AskToProceedGenProfStage(YesNoStage):
	domonitor_forbidden = True
	# mega --> gen
	def __init__(self):
		message=errorcode.msg_W101_gen
		YesNoStage.__init__(self, message, self.yes_cb, self.no_cb, '', uiconfig.baloon_phone_setting_icon)
	def yes_cb(self):
 		setting.megaAPEnabled = 0
 		setting._save()

		stage = runtime.manager.find_stage('init ipnetwork', True)
		if stage:
			message=errorcode.msg_Wait
			stage.change_message(message)
		
			stage.start_gen_ap_conn(True)
			runtime.manager.back_stage()
		
	def no_cb(self):
		message=errorcode.msg_W101_1
		errorcode.set_idle_errmsg(message, 'W101')
		#runtime.manager.back_stage()
		runtime.manager.change_stage(IdleStage, True)
#MMW	2008.0622	network error message to dect
		utils.send_VP_net_status_to_DCT('W101')
#end of MMW			
		
class AskToProceedConfigStage(YesNoStage):	
	domonitor_forbidden = True
	def __init__(self):
		message=errorcode.msg_W101_scan%'Mega AP'
		YesNoStage.__init__(self, message, self.yes_cb, self.no_cb, '', uiconfig.baloon_phone_setting_icon)
	
	def yes_cb(self):
		stage = newprof.WirelessScanWaitStage
		runtime.manager.change_stage(stage, True)
	def no_cb(self):
#		runtime.manager.back_stage()
		message=errorcode.msg_W101_1
		errorcode.set_idle_errmsg(message, 'W101')
		runtime.manager.change_stage(IdleStage, True)
#MMW	2008.0622	network error message to dect
		utils.send_VP_net_status_to_DCT('W101')
#end of MMW		


def activateMegaApCfg():
	debugLogN('activateMegaApCfg()')
	try :
		os.remove('/usr/etc/wireless.cfg')
	except :
		pass
	os.system('cp /usr/etc/wireless_kt_default.cfg /usr/etc/wireless.cfg')
	os.system('sync')
	profile.wifi_profile = profile.wifi_profile_kt_default
	
def deactivateMegaApCfg():
	debugLogN('deactivateMegaApCfg()')
	try :
		os.remove('/usr/etc/wireless.cfg')
	except :
		pass
	os.system('cp /usr/etc/wireless_general.cfg /usr/etc/wireless.cfg')
	os.system('sync')
	profile.wifi_profile = profile.wifi_profile_general

def disableGenMacMode():
	debugLogN('disableGenMacMode() - force')
	#profile.wifi_profile_general.mac_mode_on = 'no'
	#profile.wifi_profile_general.save()
	#os.system('sync')	
	os.system('wl macmode 0 &')
	#deactivateMegaApCfg()

def disableMegaMacMode():
	debugLogN('disableMegaMacMode() - force')
	#profile.wifi_kt_default.mac_mode_on = 'no'
	#profile.wifi_profile_general.save()
	#os.system('sync')	
	
	os.system('wl macmode 0 &')
	#activateMegaApCfg()