import xml.sax.handler
import os
import config
import utils
import status
from vdcisetting import vdci_setting
from basemodel import NotifyStage, Stage
import runtime
import phonesetting
from update import DownloadUI, DownloadStage
import myannapp
from setting import setting
import string


def get_serialno():
	fp = os.popen("serialno","r")
        serialnumber = fp.readline().strip()
        fp.close()
	return serialnumber


def get_mac_address():
	fp = os.popen("serialno mac","r")
        mac_address = fp.readline().strip()
        fp.close()
	return mac_address.replace(':','')

def get_model():
	fp = file("/usr/local/lgvp/var/product_model.info")
	model = fp.readline().split("#")[1].strip()
	fp.close()
	return model

def get_version():
	fp = file("/usr/local/lgvp/var/product_model.info")
	version = fp.readline().split("#")[2].strip()
	fp.close()
	return version


class Provision_Notify(NotifyStage):
	name = 'provision notify'
	def __init__(self, message,noexit=False,duration=0,cb=None, exit_cb=None):
		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, None, 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):
				if config.provision_debug :
					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):
				if config.provision_debug :
					print '** Ignore key(2) - ', key
				return True

		NotifyStage.handle_key(self,key)
# Here
	
class docHandler(xml.sax.handler.ContentHandler):
	def __init__(self):
		if config.provision_debug :
			print "init"
		self.prov_url=''
		self.sip_server=''
		self.sip_username=''	# display name
		self.auth_name=''	# display name
		self.domain=''   #new
		self.sip_uri=''   #sip:phone number
		self.tel_num = '' #new
		self.sip_password=''
		self.sip_transport=''
		self.sip_port='' #new
		self.sip_expires='' #new
		self.itsp_support='' #new
		self.prov_resync=''
		self.prov_resync_random=''
		self.prov_resync_random_failure=''
		self.software_upgrade_url=''
		self.ntp_server='' #new
		self.time_zone='' #new
		self.nat_timer='' #new
		self.day_light_savings='' #new
		self.linkspeed_down='' #new
		self.linkspeed_up='' #new
	
	def startElement(self, name, attr):
		self.elem_name = name
	
	def characters(self, data):
		if self.elem_name == 'prov_url':
			self.prov_url += data.strip()
		elif self.elem_name == 'PROXY_ADDRESS' or self.elem_name == 'sip_server':
			self.sip_server += data.strip()
		elif self.elem_name == "sip_username" : 
			self.sip_username += data.strip()
		elif	self.elem_name == "AUTH_NAME" or self.elem_name == "auth_name":
			self.auth_name += data.strip()
		elif self.elem_name == 'DOMAIN' or self.elem_name == 'domain':
			self.domain += data.strip()
		elif self.elem_name == 'PROXY_PORT' or self.elem_name == 'proxy_port':
			self.sip_port += data.strip() #new
		elif self.elem_name == 'EXPIRES' or self.elem_name == 'expires':
			self.sip_expires += data.strip() #new
		elif self.elem_name == 'ITSP_SUPPORT' or self.elem_name == 'itsp_support': #new
			self.itsp_support += data.strip()	
		elif self.elem_name == 'TEL_NUM' or self.elem_name == 'tel_num':   #new
			self.tel_num += data.strip()	
		elif self.elem_name == "sip_uri" or self.elem_name == 'SIP_URI':
			self.sip_uri += data.strip()
		elif self.elem_name == "sip_password" or self.elem_name == "AUTH_PWD" or self.elem_name == "auth_pwd":
			self.sip_password += data.strip()
		elif self.elem_name == "sip_transport":
			self.sip_transport += data.strip()
		elif self.elem_name == "prov_resync":
			self.prov_resync += data.strip()			
		elif self.elem_name == "prov_resync_random":
			self.prov_resync_random += data.strip()
		elif self.elem_name == "prov_resync_random_failure":
			self.prov_resync_random_failure += data.strip()
		elif self.elem_name == "software_upgrade_url":
			self.software_upgrade_url += data.strip()
		elif self.elem_name == "NTP" or self.elem_name == "ntp":
			self.ntp_server += data.strip() #new
		elif self.elem_name == "ZONE" or self.elem_name == "zone":
			self.time_zone += data.strip() #new
		elif self.elem_name == "DAYLIGHTSAVINGS" or self.elem_name == "daylightsavings":
			self.day_light_savings += data.strip() #new
		elif self.elem_name == "NAT_TIMER" or self.elem_name == "nat_timer": #new
			self.nat_timer += data.strip()
		elif self.elem_name == "LINKSPEED_DOWN" or self.elem_name == "linkspeed_down": #new
			self.linkspeed_down += data.strip()
		elif self.elem_name == "LINKSPEED_UP" or self.elem_name == "linkspeed_up": #new
			self.linkspeed_up += data.strip()
			
			
class Provision:
	def __init__(self):
		if config.provision_debug :	
			print "provisioning initialize code"
		self.prov_url=''
		self.sip_server=''
		self.sip_username=''
		self.auth_name=''
		self.domain=''   #new
		self.sip_uri=''   #sip:phone number
		self.tel_num = '' #new
		self.sip_password=''
		self.sip_transport=''
		self.sip_port='' #new
		self.sip_expires='' #new
		self.itsp_support='' #new
		self.prov_resync=''
		self.prov_resync_random=''
		self.prov_resync_random_failure=''
		self.software_upgrade_url=''
		self.ntp_server='' #new
		self.time_zone='' #new
		self.nat_timer='' #new
		self.day_light_savings='' #new
		self.linkspeed_down='' #new
		self.linkspeed_up='' #new

		#first time flag
		#self.first_time_done = False
		self.pid = 0
	
	def do_xml_parser(self, initial_time = False):
		parser=xml.sax.make_parser()
		aptcfg = docHandler()	
		parser.setContentHandler(aptcfg)
		parser.parse(config.provision_data)
		self.prov_url = str(aptcfg.prov_url)
		self.prov_url = self.prov_url.replace("SERIALNUMBER",get_serialno()[:14])
		self.prov_url = self.prov_url.replace("MAC_ADDRESS_MAIN_ETHERNET", get_mac_address())

		if config.provision_debug :
			print 'self.prov_url = ', self.prov_url		
		if initial_time == True :
			#save URL to file
			fp = open(config.provision_url_site, 'w')
			fp.write(self.prov_url)
			fp.close()
			if config.provision_debug :
				print 'getting URL site', open(config.provision_url_site).read()
			return
		self.sip_server = str(aptcfg.sip_server)
		self.sip_username = str(aptcfg.sip_username)
		self.auth_name = str(aptcfg.auth_name)
		self.domain = str(aptcfg.domain) #new
		self.sip_uri = str(aptcfg.sip_uri)   #sip:phone number
		self.tel_num = str(aptcfg.tel_num) #new
		self.sip_password = str(aptcfg.sip_password)
		self.sip_transport = str(aptcfg.sip_transport)
		self.sip_port = str(aptcfg.sip_port) #new
		self.sip_expires = str(aptcfg.sip_expires) #new
		self.itsp_support = str(aptcfg.itsp_support) #new
		self.prov_resync = str(aptcfg.prov_resync)
		self.prov_resync_random = str(aptcfg.prov_resync_random)
		self.prov_resync_random_failure = str(aptcfg.prov_resync_random_failure)

			#Resync.load()
		#elif self.first_time_done == False : 
			# load Resync just 1 time
			#self.first_time_done = True
			#Resync.load()
	
		self.software_upgrade_url = str(aptcfg.software_upgrade_url)

		self.ntp_server = str(aptcfg.ntp_server) #new		
		self.time_zone = str(aptcfg.time_zone) #new 		
		self.nat_timer = str(aptcfg.nat_timer) #new		
		self.day_light_savings = str(aptcfg.day_light_savings) #new		
		self.linkspeed_down = str(aptcfg.linkspeed_down) #new		
		self.linkspeed_up = str(aptcfg.linkspeed_up) #new
		
		if config.provision_debug :
			print 'self.sip_server = ', self.sip_server
			print 'self.sip_username = ', self.sip_username
			print 'self.auth_name = ', self.auth_name
			print 'self.domain = ', self.domain				
			print 'self.sip_uri = ', self.sip_uri	
			print 'self.tel_num = ', self.tel_num	
			print 'self.sip_password = ', self.sip_password
			print 'self.sip_transport = ', self.sip_transport
			print 'self.sip_port = ', self.sip_port	
			print 'self.sip_expires = ', self.sip_expires
			print 'self.itsp_support = ', self.itsp_support
			print 'self.prov_resync = ', self.prov_resync		
			print 'self.prov_resync_random = ', self.prov_resync_random
			print 'self.prov_resync_random_failure = ', self.prov_resync_random_failure
			print 'self.ntp_server = ', self.ntp_server	
			print 'self.time_zone = ', self.time_zone
			print 'self.nat_timer = ', self.nat_timer
			print 'self.day_light_savings = ', self.day_light_savings		
			print 'self.linkspeed_down = ', self.linkspeed_down
			print 'self.linkspeed_up = ', self.linkspeed_up		
			
			print 'self.software_upgrade_url = ', self.software_upgrade_url

		
	def do_initial_provisioning(self, site):
		
		#ret = os.system("wget2 http://150.150.141.139/prov/\?%s\&%s --header=\"model:%s\" --header=\"version:%s\" -O /tmp/provision" % (get_serialno(), get_mac_address(), get_model(),get_version()))
		#cmd = "wget2 http://150.150.141.139/prov/\?%s\&%s --header=\"model:%s\" --header=\"version:%s\" -O %s" % (get_serialno(), get_mac_address(), get_model(),get_version(), config.provision_data)
		#ret = os.system("wget2 ftp://150.150.141.112/test.xml -O /tmp/provision")
		#cmd = 'wget2 %s -O %s -T 5 -t 1'%(site, config.provision_data)
		#cmd = 'wget2 %s -O %s -T 5 -t 1'%(site, config.provision_data)
		if config.provision_debug :
			#cmd = 'wget2 -d -T 5 -t 1 --certificate=/usr/etc/tandberg.crt --private-key=/usr/etc/tandberg.key --ca-certificate=/usr/etc/ca-cert.pem --no-check-certificate --user-agent=\"LG-Sandwich%sv%s\" %s/%s/%s -O %s' % (' ', get_version(), site,get_serialno()[:14], get_mac_address(),config.provision_data)
			cmd = 'wget2 -d -T 5 -t 1 --certificate=/usr/etc/tandberg.crt --private-key=/usr/etc/tandberg.key --ca-certificate=/usr/etc/ca-cert.pem --no-check-certificate USERAGENT %s/%s/%s -O %s' % (site,get_serialno()[:14], get_mac_address(),config.provision_data)
		else :
			cmd = 'wget2 -q -T 5 -t 1 --certificate=/usr/etc/tandberg.crt --private-key=/usr/etc/tandberg.key --ca-certificate=/usr/etc/ca-cert.pem --no-check-certificate USERAGENT %s/%s/%s -O %s' % (site,get_serialno()[:14], get_mac_address(),config.provision_data)
		#ret = os.system(cmd)
		#return ret
		ret = self.fork_process(cmd)
		return ret
		
	def do_provisioning(self, site):
		#ret = os.system("wget2 %s  --certificate=/usr/etc/client.pem --no-check-certificate --header=\"model:%s\" --header=\"version:%s\" -O /tmp/provision" % (self.prov_url, get_model(),get_version()))
		#ret = os.system("wget2 ftp://150.150.141.112/test.xml -O /tmp/provision")
		#ret = os.system("wget2 ftp://150.150.141.112/test.xml -O /tmp/provision")
		#cmd = 'wget2 -T 5 --certificate=/usr/etc/tandberg.crt --private-key=/usr/etc/tandberg.key --ca-certificate=/usr/etc/ca-cert.pem --no-check-certificate --user-agent=\"LG-Sandwich v%s\" %s -O /tmp/provision' % (get_version(), site)
		#cmd = 'wget2 %s -O %s -T 5 -t 1'%(site, config.provision_data)
		if config.provision_debug :
			cmd = 'wget2 -d -T 5 -t 1 --certificate=/usr/etc/tandberg.crt --private-key=/usr/etc/tandberg.key --ca-certificate=/usr/etc/ca-cert.pem --no-check-certificate USERAGENT %s -O %s' % (site, config.provision_data)
		else :
			cmd = 'wget2 -q -T 5 -t 1 --certificate=/usr/etc/tandberg.crt --private-key=/usr/etc/tandberg.key --ca-certificate=/usr/etc/ca-cert.pem --no-check-certificate USERAGENT %s -O %s' % (site, config.provision_data)
		#ret = os.system(cmd)
		#return ret
		ret = self.fork_process(cmd)
		return ret

	def fork_process(self, cmd)  :
		if self.pid != 0 :
			ret = self.provision_child_process_check()
			if ret == 256 :
				if config.provision_debug :
					print 'keck!!!'
			if config.provision_debug :
				print 'provisioning return', ret
			return ret

		try :
			self.pid = os.fork()
		except :
			print 'provisioning fork except error'
			return 'False'			

		if self.pid != 0 : # parent
			if config.provision_debug :
				print 'parent process gogo!!'
				print 'parent pid', os.getpid()
				print 'child pid', self.pid	
			return 'True'
		
		else :	#child process
			if config.provision_debug :		
				print 'child process'
				print 'child pid', os.getpid()
				print 'parent pid', os.getppid()
	
			cmds = cmd.strip()
			cmd = cmds.split(' ')
			index = cmd.index("USERAGENT")
			cmd[index] = "--user-agent=\"LG-Sandwich v%s\""%get_version()

			if config.provision_debug :
				print 'cmd=', cmd
			os.execlp('wget2', *cmd)

	def provision_child_process_check(self) :
		if config.provision_debug :
			print 'provision_child_process_check pid =', self.pid
		#print 'parent pid', os.getpid()
		#print 'child pid', self.pid		
		
		if self.pid != 0 :
			wpid, ret = os.waitpid(self.pid, os.WNOHANG)
			if config.provision_debug :
				print 'wait pid = ', wpid
				print 'wait pid ret = ', ret 
				print 'self.pid = ', self.pid

			if self.pid != wpid :
				if ret == 256 :
					if config.provision_debug :
						print 'keck!!!'
					return ret
				elif wpid == 0 and ret == 0 :
					if config.provision_debug :
						print 'what the heck!!!'
					procstat = self.get_proc_status()
					if config.provision_debug :
						print 'procstat =', procstat 
					if procstat == 'S' or procstat == 'Z' :
						return ret
					elif 	procstat == 'E' :
						self.pid = 0
						return 'False'
				else :
					if config.provision_debug :
						print 'e wait pid = ', wpid
						print 'e wait pid ret = ', ret 
						print 'e self.pid = ', self.pid
					return ret
			else :
				if ret != 0 :
					if config.provision_debug :
						print 'wpid= %d, self pid = %d, ret=%d'%(wpid, self.pid, ret)
					self.pid = 0
					return 'False'
				os.system('sync')		
				os.system('sync')
				os.system('sync')	
				self.pid = 0

				return 'True'			
		else :
			self.pid = 0		
			return 'True'

	def get_proc_status(self):
		try:
			strs = open('/proc/%d/stat'%self.pid).read().split(' ')
			#print 'GET PROC_STATUS', strs
			return strs[2]
		except:
			print 'exception : get_proc_status', self.pid  # the process finished or file name error
			
			return 'E'			

	def destroy(self):
		print 'Provision destroy'


#telio_site='/usr/etc/telio_site.cfg'
#provision_url_site='/usr/etc/telio_provision_site.cfg'
#provision_data='/tmp/provison'
#resync_time_file='/usr/etc/prov_resync.cfg'


class ProvisionManager:
	def __init__(self):
		if config.provision_debug :
			print 'Provision manger init'
		self.provison = Provision()
		self.telio_site = None
		self.provision_url = None
		self.timer = None	# primary provision timer
		self.timer2 = None # for UI show
		self.register_download_status = 1

		#get resync, random failure time
		self.resync_load = False
		self.resync_time = 3600
		self.resync_random = 0.1
		self.resync_random_failure = 120		# initial value
		self.normal_status = True
		self.provisioning = False
		self.sip_change_applied = True

		#first provision no need because of back ground
		#self.first_provision = True
		
		self.check_initial_boot()


			
	def check_initial_boot(self):	#call this func after network initialized at manager
		self.resync_file_load()
		# check provision url site file 
		if not os.access(config.provision_url_site, os.R_OK) :
			self.telio_site	= open(config.telio_site).read().strip()
			if config.provision_debug :
				print 'telio site', self.telio_site		
				print 'provision url site is not exist so go initial boot process'
				print 'get URL file from telio site'
				print 'first network check and then file get'
			self.URL_file_get()

		else :

			self.provision_url = open(config.provision_url_site).read().strip()
			if config.provision_debug :
				print 'provision url', self.provision_url
				print 'site is exist, so go to provision state'
			#set URL to Provision class and do provisioning
			self.provision_start()

	def resync_file_load(self):
		if self.resync_load == False :
			if not os.access(config.resync_time_file, os.R_OK) :
				if config.provision_debug :			
					print 'Making Prov resync time file!!!!!!!!!!!!!!!!!!!!!'
				fp = open(config.resync_time_file, 'w')
				fp.write('%s=%s\n' % ('resync', Resync.resync))
				fp.write('%s=%s\n' % ('resync_random', Resync.resync_random))
				fp.write('%s=%s\n' % ('resync_random_failure', Resync.resync_random_failure))
				fp.close()
				Resync.load()
			else :
				Resync.load()
				self.resync_time = float(Resync.resync)
				self.resync_random = float(Resync.resync_random)
				self.resync_random_failure = float(Resync.resync_random_failure)
			self.resync_load = True
			


	def URL_file_get(self):	
		if self.timer != None :
			self.timer = None	
		#net work check
		if status.network_status != status.NetOk :
			# net work is not ok so try 5 sec later	
			#print 'network is not ready retry %d sec later'%int(self.resync_random_failure)			
			#self.timer = utils.Timer(int(self.resync_random_failure)*1000,\
			#self.URL_file_get)
			if config.provision_debug :
				print 'network is not ready retry 5 sec later'			
			self.timer = utils.Timer(5 * 1000,\
			self.URL_file_get)

		else :
			#fork wget for back ground process, wait till get file and watch child process 
			ret = prov.do_initial_provisioning(self.telio_site)
			if config.provision_debug :
				print 'URL fork', ret
			if ret == 'True' :
				self.timer = utils.Timer(config.provision_process_watch_time * 1000,\
				self.URL_file_get_watch)
			elif ret == 'False' :	# fork fail, some time later fork again, temporary 3 sec later
				self.timer = utils.Timer(config.provision_process_watch_time  * 1000,\
				self.URL_file_get)
			else :
				if config.provision_debug :
					print 'ret, what should I need to do... nothing??', ret 
				self.timer = utils.Timer(config.provision_process_watch_time * 1000,\
				self.URL_file_get)
				'''
			if prov.do_initial_provisioning(self.telio_site) == 0 :	#file get success
				print 'URL file get success'
				prov.do_xml_parser(True)
				self.provision_url = prov.prov_url
				print 'URL file get provision URL', self.provision_url
				self.provision_start() 
			else :
				print 'URL network is not readyretry 5 sec later'
				print 'time', int(self.resync_random_failure)
				self.timer = utils.Timer(int(self.resync_random_failure) * 1000,\
				self.URL_file_get)
				'''
				
	def URL_file_get_watch(self) :
		if self.timer != None :
			self.timer = None	
		if config.provision_debug :
			print 'URL_file_get_watch'
		ret = prov.provision_child_process_check()
		if ret == 'True' :	# success
			if config.provision_debug :
				print 'URL file get success'
			prov.do_xml_parser(True)
			self.provision_url = prov.prov_url
			if config.provision_debug :
				print 'URL file get provision URL', self.provision_url
			self.provision_start() 		
		elif ret == 'False' : 	# fail
			if config.provision_debug :
				print 'URL file get fail retry random fail retry time'
				print 'time', int(self.resync_random_failure)
			self.timer = utils.Timer(int(self.resync_random_failure) * 1000,\
			self.URL_file_get)
		else :
			if config.provision_debug :
				print 'URL_file_get_watch wait??, ret =', ret
			self.timer = utils.Timer(config.provision_process_watch_time * 1000,\
			self.URL_file_get_watch)			
			

				
	def provision_start(self) :
		if self.timer != None :
			self.timer = None	
		if status.network_status != status.NetOk :
			# net work is not ok so try 5 sec later	
#			if config.provision_debug :
#				print 'provision start network is not ready retry %d sec later'%int(self.resync_random_failure)			
#			self.timer = utils.Timer(int(self.resync_random_failure)*1000,\
#			self.provision_start)	
			if config.provision_debug :
				print 'provision start network is not ready retry 5 sec later'		
			self.timer = utils.Timer(5*1000,\
			self.provision_start)
		else :
			ret = prov.do_provisioning(self.provision_url)
			if config.provision_debug :
				print 'provision_start fork', ret
			if ret == 'True' :
				self.timer = utils.Timer(config.provision_process_watch_time * 1000,\
				self.Provision_watch)
			elif ret == 'False' :	# fork fail, some time later fork again, temporary 3 sec later
				self.timer = utils.Timer(config.provision_process_watch_time * 1000,\
				self.provision_start)
			else :
				if config.provision_debug :		
					print 'ret, provisin start what should I need to do... nothing??', ret 
				self.timer = utils.Timer(config.provision_process_watch_time * 1000,\
				self.provision_start)			
				'''
			if prov.do_provisioning(self.provision_url) == 0 :
				prov.do_xml_parser()
				self.resync_file_load()	
				# if SW updat site is exist, go to download stage 
				#compare original data with new getting data
				if self.Compare_with_getting_data() != True :
					# first auto cof or vdci.cfg value is changed so run vdciapp again
					print 'I have to do from here!!!!!!!!!!!!!'
					if prov.software_upgrade_url != '' :
						print 'go to download stage'
					else : 
						print 'go to sip register stage'
				else :
					if prov.software_upgrade_url != '' :
						print 'go to download stage'
					else :
						print 'resync timer set'
						self.timer = utils.Timer(int(self.resync_time * self.resync_random)*1000,\
						self.provision_start)
						
			else :
				#fail so,,, start after resync_random_failure time
				print 'provision start fail to get provision data'
				self.timer = utils.Timer(int(self.resync_random_failure)*1000,\
				self.provision_start)
				'''

	def Provision_watch(self) :
		if self.timer != None :
			self.timer = None	
		if config.provision_debug :	
			print 'Provision_watch'
		ret = prov.provision_child_process_check()
		if config.provision_debug :
			print 'ret =', ret
		if ret == 'True' :	# success
			try :
				prov.do_xml_parser()
			except :
				print 'provision xml data parse error some time later fork again'
				if self.timer != None :
					self.timer = None	
				# set fail timer	
				self.timer = utils.Timer(int(self.resync_random_failure) * 1000,\
				self.provision_start)			
				return
			#self.resync_file_load()	
			# if SW updat site is exist, go to download stage 
			#compare original data with new getting data
			if self.Compare_with_getting_data() != True :
				self.sip_change_applied = False			
				# first auto cof or vdci.cfg value is changed so run vdciapp again
				if prov.software_upgrade_url != '' :
					if config.provision_debug :
						print 'go to download stage'
					self.register_download_status = 2
					self.show_provision()
				else : 
					if config.provision_debug :
						print 'go to sip register stage'
					self.register_download_status = 1
					self.show_provision()
			else :
				if prov.software_upgrade_url != '' :
					if config.provision_debug :
						print 'go to download stage'
					self.register_download_status = 2
					self.show_provision()
				else :
					if config.provision_debug :
						print 'resync timer set ', int(self.resync_time * self.resync_random)
			self.timer = utils.Timer(int(self.resync_time * self.resync_random)*1000,\
			self.provision_start)		
		elif ret == 'False' : 	# fail
			#fail so,,, start after resync_random_failure time
			if config.provision_debug :
				print 'provision start fail to get provision data'
			self.timer = utils.Timer(int(self.resync_random_failure)*1000,\
			self.provision_start)
		else :
			if config.provision_debug :
				print 'Provision_watch wait??, ret =', ret
			self.timer = utils.Timer(config.provision_show_wait_time * 1000,\
			self.Provision_watch)			



	def Compare_with_getting_data(self):
		# provision URL change URL 
		if config.provision_debug :
			print 'Compare data'
		data_same = True
		if self.provision_url != prov.prov_url :	#self.provision_url => original URL, prov.prov_url => new URL
			if config.provision_debug :
				print 'keck!!!!!!!!!!!!!!!'
				print 'self.provision_url', self.provision_url
				print 'prov.prov_url', prov.prov_url

		# vdci data register with new value

		if vdci_setting.proxy_addr != prov.sip_server :
			vdci_setting.set_proxy_addr(prov.sip_server)
			if config.provision_debug :
				print 'sip server different'
			data_same = False

		if vdci_setting.display_name != prov.sip_username :
			vdci_setting.set_display_name(prov.sip_username)
			if config.provision_debug :
				print 'sip username different'			
			data_same = False

		if vdci_setting.auth_name != prov.auth_name :
			vdci_setting.set_auth_name(prov.auth_name)
			if config.provision_debug :
				print 'sip auth_name different'			
			data_same = False			

		if vdci_setting.domain != prov.domain :
			vdci_setting.set_domain(prov.domain)
			if config.provision_debug :
				print 'sip domain different'			
			data_same = False

		if vdci_setting.sip_uri != prov.sip_uri :
			vdci_setting.set_sip_uri(prov.sip_uri)
			if config.provision_debug :
				print 'sip uri different'			
			data_same = False

		if vdci_setting.tel_num != prov.tel_num :
			vdci_setting.set_tel_num(prov.tel_num)
			if config.provision_debug :
				print 'tel num different'			
			data_same = False
	
			'''
		if vdci_setting.auth_name != prov.sip_uri[4:] :
			data=str(prov.sip_uri[4:].strip())
#			print 'data', data, type(data) 
			vdci_setting.set_auth_name(data)
			if config.provision_debug :
				print 'auth name different'				
			data_same = False
			'''
			
		if vdci_setting.auth_pwd != prov.sip_password :
			vdci_setting.set_auth_pwd(prov.sip_password)
			if config.provision_debug :
				print 'auth pwd different'				
			data_same = False

		if prov.sip_transport == 'udp' :
			prov.sip_transport = '0'
		elif prov.sip_transport == 'tcp' :
			prov.sip_transport = '1'
		else :
			prov.sip_transport = '0'

		if vdci_setting.transport_mode != prov.sip_transport :
			vdci_setting.set_sip_transport(prov.sip_transport)
			print 'sip transport different'			
			data_same = False

		if vdci_setting.expires != prov.sip_expires :
			vdci_setting.set_expires(prov.sip_expires)
			print 'sip expire different'			
			data_same = False		

		if vdci_setting.itsp_support != prov.itsp_support :
			vdci_setting.set_itsp(prov.itsp_support)
			print 'sip itsp different'			
			data_same = False	
			
		if vdci_setting.nat_timer != prov.nat_timer :
			vdci_setting.set_nat_timer(prov.nat_timer)
			print 'sip nat_timer different'			
			data_same = False	
			


		# resync, failure time change sync time # original => Resync, new data => prov	
		if Resync.resync != prov.prov_resync : 
			if config.provision_debug :
				print 'resync different'			
			Resync.set_resync(prov.prov_resync)
			self.resync_time = float(prov.prov_resync)
		if Resync.resync_random != prov.prov_resync_random :
			if config.provision_debug :
				print 'resync_random different'
				print 'resync_random=', prov.prov_resync_random
			Resync.set_resync_random(prov.prov_resync_random)
			self.resync_random = float(prov.prov_resync_random)
			if config.provision_debug :
				print 'self.resync_random=', self.resync_random
		if Resync.resync_random_failure != prov.prov_resync_random_failure: 
			if config.provision_debug :
				print 'resync_random_failure different'			
			Resync.set_resync_random_failure(prov.prov_resync_random_failure)
			self.resync_random_failure = float(prov.prov_resync_random_failure)

		#if self.first_provision == True :
		#	self.first_provision = False	
		#	return False	# do register at first time

		# NTP setting
		self.Provision_NTP_setting(prov.ntp_server, prov.time_zone, prov.day_light_savings)

		
		return data_same	

	def Provision_NTP_setting(self, ntp_server = 'ntp.telio.no', timezone = 'GMT+1', daylightsaving = 'enable'):
		run_ntp = False
		if config.provision_debug :
			print 'ntp server = ', ntp_server
			print 'timezone = ',  timezone
			print 'daylightsaving = ', daylightsaving
		if ntp_server != setting.get_ntpserver():
			if config.provision_debug :
				print 'original ntp server = ', setting.get_ntpserver()
				print 'ntp server is different'
			setting.set_ntpserver(ntp_server)
			run_ntp = True
			
		if timezone == 'GMT' :
			timezone_set = '0'
		else :
			timezone_set = timezone[4:]
		if config.provision_debug :
			print 'changed timezone = ', timezone_set

		if timezone_set != setting.ntp_timezone :
			if config.provision_debug :
				print 'time zone is different'		
			setting.set_ntptimezone(timezone_set)
			run_ntp = True

		if daylightsaving == 'enable' :
			daylightsaving_set = 1
		else :
			daylightsaving_set = 0

		if daylightsaving_set != setting.ntp_summertime :
			if config.provision_debug :
				print 'daylight save is different'	
			setting.set_ntpsummertime(daylightsaving_set)
			run_ntp = True

		if run_ntp == True :
			if config.provision_debug :
				print 'ntp_run by provision'			
			runtime.manager.ntp_run()


	def show_provision(self):
		if self.timer2 != None :
			self.timer2 = None	
		if status.call_status != status.NotSelected :	#when busy, wait for 1 sec
			if config.provision_debug :
				print 'show provision, busy'
			self.normal_status = False
			self.timer2 = utils.Timer(config.provision_show_wait_time * 1000,\
			self.show_provision)			
		elif runtime.myannapp != None and runtime.myannapp.is_running() :
			if config.provision_debug :
				print 'show provision, browser busy'
			self.normal_status = False
			"""
			myannapp.active_myann(False)
			runtime.eaHandler.deactivateApplication_browser()
			"""
			self.timer2 = utils.Timer(config.provision_show_wait_time * 1000,\
			self.show_provision)			
		else :
			if runtime.manager.stage.name == 'provision notify' : #if stage is provision notify, just wait
				if config.provision_debug :
					print 'provision notify stage, so just wait'
			else :
				"""
				if runtime.manager.stage.name != 'idle'  :
					if config.provision_debug :
						print 'wait till idle stage'
					self.timer2 = utils.Timer(config.provision_show_wait_time * 1000,\
					self.show_provision)			
				else :
					if config.provision_debug :
						print 'go to provision notify stage'
					self.normal_status = True
					#set to busy status
					self.provisioning = True
					prov_message = _('Provision success')
					stage = Provision_Notify(message = prov_message , noexit=True, duration = 3*1000, cb=self.back_cb)
					runtime.manager.stack_stage(stage)
				"""
				
				if self.normal_status == False and runtime.manager.stage.name != 'idle'  :
					if config.provision_debug :
						print 'wait till idle stage'
					self.timer2 = utils.Timer(config.provision_show_wait_time * 1000,\
					self.show_provision)			
				else :
					if config.provision_debug :
						print 'go to provision notify stage'
					self.normal_status = True
					#set to busy status
					self.provisioning = True
					prov_message = _('Provision success')
					stage = Provision_Notify(message = prov_message , noexit=True, duration = 3*1000, cb=self.back_cb)
					runtime.manager.stack_stage(stage)
				
	def back_cb(self):
		runtime.manager.back_stage()
		if self.register_download_status == 1 :
			if config.provision_debug :
				print 'back stage and go to sip register'
			#stage = NotifyStage(_('SIP setting is changed'), uiconfig.baloon_setting_system_reset_icon, self.registering)
			if self.sip_change_applied == False :
				self.sip_change_applied = True
				if config.provision_debug :
					print 'SIP changed not applied so, apply SIP changed'
			stage = Provision_Notify(message = _('SIP setting is changed') , noexit=True, duration = 3*1000, cb=self.registering)
#			stage = NotifyStage(_('SIP setting is changed'), None, self.registering)
			runtime.manager.stack_stage(stage)
		elif self.register_download_status == 2 :
			if config.provision_debug :
				print 'back stage and go to download stage'
#			runtime.manager.change_stage(DownloadStage(site=prov.software_upgrade_url))
			self.start_download()
#			self.timer = utils.Timer(config.provision_show_wait_time * 2000,\
#			self.start_download)			
		else :
			if config.provision_debug :
				print 'just back stage'
			if self.sip_change_applied == False :
				self.sip_change_applied = True
				if config.provision_debug :
					print 'SIP changed not applied so, apply SIP changed'
				stage = Provision_Notify(message = _('SIP setting is changed') , noexit=True, duration = 3*1000, cb=self.registering)
#				stage = NotifyStage(_('SIP setting is changed'), None, self.registering)
				runtime.manager.stack_stage(stage)
			

	def start_download(self):
		if self.timer != None :
			self.timer = None	
		if status.network_status != status.NetOk :
			# net work is not ok so try 5 sec later	
#			if config.provision_debug :
#				print 'provision start network is not ready retry %d sec later'%int(self.resync_random_failure)			
#			self.timer = utils.Timer(int(self.resync_random_failure)*1000,\
#			self.provision_start)	
			if config.provision_debug :
				print 'provision start network is not ready retry 5 sec later'		
			self.timer = utils.Timer(5*1000,\
			self.start_download)
		else :
			if status.call_status != status.NotSelected :	#when busy, wait for 1 sec
				if config.provision_debug :
					print 'start_download, busy'
				self.normal_status = False
				self.timer = utils.Timer(config.provision_show_wait_time * 1000,\
				self.start_download)			
			elif runtime.myannapp != None and runtime.myannapp.is_running() :
				if config.provision_debug :
					print 'start_download, browser busy'
				self.normal_status = False
				"""
				myannapp.active_myann(False)
				runtime.eaHandler.deactivateApplication_browser()
				"""
				self.timer = utils.Timer(config.provision_show_wait_time * 1000,\
				self.start_download)
			else :	
				if runtime.manager.stage.name != 'idle'  :
					if config.provision_debug :
						print 'wait till idle stage'
					self.timer = utils.Timer(config.provision_show_wait_time * 1000,\
					self.start_download)			
				else :
					if config.provision_debug :
						print 'go to downloadstage'
					self.normal_status = True
					#set to busy status
					self.provisioning = True
					stage = DownloadStage(site=prov.software_upgrade_url)
					runtime.manager.change_stage(stage)
				"""
				if self.normal_status == False and runtime.manager.stage.name != 'idle'  :
					if config.provision_debug :
						print 'wait till idle stage'
					self.timer = utils.Timer(config.provision_show_wait_time * 1000,\
					self.start_download)			
				else :
					if config.provision_debug :
						print 'go to downloadstage'
					self.normal_status = True
					#set to busy status
					self.provisioning = True		
					runtime.manager.change_stage(DownloadStage(site=prov.software_upgrade_url))
				"""	

		

	def download_fail_retry(self):
		if self.timer != None :
			self.timer = None
		#set busy status to normal status
		self.provisioning = False	
		os.system('rm -f /tmp/down_file')
		self.timer = utils.Timer(int(self.resync_random_failure)*1000,\
		self.start_download)
		if self.sip_change_applied == False :
			self.sip_change_applied = True
			if config.provision_debug :
				print 'SIP changed not applied so, apply SIP changed'
			stage = Provision_Notify(message = _('SIP setting is changed') , noexit=True, duration = 3*1000, cb=self.registering)
			runtime.manager.stack_stage(stage)		
			

	def registering(self):		
		stage = phonesetting.AutoRegisteringStage()
		runtime.manager.change_stage(stage, True)	
		#set busy status to normal status
		self.provisioning = False

	def isProvisioning(self):
		return self.provisioning

			
		'''
	def down_back_cb(self):
		runtime.manager.back_stage()

						
	def reg_back_cb(self):
		runtime.manager.back_stage()
		'''

	def destroy(self):
		self.timer = None		
		self.timer2 = None
		
class ResynctimeSetting:
	def __init__(self):
		self.resync = '3600'
		self.resync_random = '0.1'
		self.resync_random_failure = '120'


	def set_resync(self, value):
		self.resync = value
		self.save()

	def set_resync_random(self, value):
		self.resync_random = value
		self.save()

	def set_resync_random_failure(self, value):
		self.resync_random_failure = value
		self.save()		


	def reset(self):
		self.__init__()
		self.save(True)

	def save(self, reset=False):
		name = config.resync_time_file
		fp = open(name, 'w')
		for key, value in self.__dict__.items():
			if key[0] != '_' and (type(value) in (type(''), type(0))):
				fp.write("%s=%s\n" % (key, value))

		return False

	
	def load(self):

		name = config.resync_time_file
		g = self.__dict__
		if os.path.exists(name):
			for line in file(name):
				line = line.strip()
				if not line:
					continue

				if line[0] == '#':
					line = line[1:]

				key, value = line.split('=', 1)

				key = key.lower()
				g[key] = value



prov = Provision()		
Resync = ResynctimeSetting()

if __name__ == '__main__':
	prov = Provision()
	
	if prov.do_initial_provisioning() == 0:
		print "initial provisioning Success!!!!"
		prov.do_xml_parser()
		#save prov_url to file
		
	#prov_url을 특정 파일에 Save해둘것.
	#만일 그 파일이 없으면 최초 provisioning으로 수행하고.
	#그 파일이 있으면 두번째 Provisioning으로 수행하면 됨.
		
	if prov.do_provisioning() == 0:
		print "provisioning success!!"
		prov.do_xml_parser()
		
		if prov.prov_url : 
			print "apply prov_url : ", prov.prov_url
		if prov.sip_server : 
			print "apply sip_server : ", prov.sip_server
		if prov.sip_username : 
			print "apply sip_username : ", prov.sip_username
		if prov.domain : #new
			print "apply domain : ", prov.domain
		if prov.sip_uri : 
			print "apply sip_uri : ", prov.sip_uri
		if prov.tel_num : #new
			print "apply tel_num : ", prov.tel_num
		if prov.sip_password : 
			print "apply sip_password : ", prov.sip_password
		if prov.sip_transport : 
			print "apply sip_transport : ", prov.sip_transport
		if prov.sip_port :  #new
			print "apply sip_port : ", prov.sip_port
		if prov.sip_expires :  #new
			print "apply sip_expires : ", prov.sip_expires
		if prov.itsp_support : #new
			print "apply itsp_support : ", prov.itsp_support
		if prov.prov_resync : 
			print "apply prov_resync : ", prov.prov_resync
		if prov.prov_resync_random : 
			print "apply prov_resync_random : ", prov.prov_resync_random
		if prov.prov_resync_random_failure : 
			print "apply prov_resync_random_failure : ", prov.prov_resync_random_failure
		if prov.software_upgrade_url : 
			print "apply software_upgrade_url : ", prov.software_upgrade_url
		if prov.ntp_server :  #new
			print "apply ntp_server : ", prov.ntp_server
		if prov.time_zone :  #new
			print "apply time_zone : ", prov.time_zone
		if prov.nat_timer :  #new
			print "apply nat_timer : ", prov.nat_timer	
		if prov.day_light_savings :  #new
			print "apply day_light_savings : ", prov.day_light_savings
		if prov.linkspeed_down : #new
			print "apply linkspeed_down : ", prov.linkspeed_down
		if prov.linkspeed_up : #new
			print "apply linkspeed_up : ", prov.linkspeed_up