import feedparser, time
import os
import status
import atexit
import time
import threading
import config
import utils
import signal
import runtime
import rss_data_get


#class RSS_reader(threading.Thread):


class RSS_reader:
	def __init__(self):
		self.pid = 0
		self.timer = None
#		self.rss_feed_site = ''				# rss feeding site 
#		self.rss_update_time =  0		# time for rss feed update
#		self.d =None

#	def run(self):
#		print 'Rss read Thread started'
#		self.rss_read()

	def rss_file_get(self):
		if self.pid != 0 :
			ret = self.rss_child_process_check()
			if ret == 256 :
				print 'keck!!!'
			print 'rss_file_get return ret = ', ret
			return ret
		try :
			self.pid = os.fork()
		except :
			print 'rss fork error'
			return 'False'
		if self.pid != 0 : # parent
			print 'parent process gogo!!'
			print 'parent pid', os.getpid()
			print 'child pid', self.pid	
			return 'True'
		
		else :	#child process
		
			print 'child process'
			print 'child pid', os.getpid()
			print 'parent pid', os.getppid()
#			if self.rss_file_check() == True:
#				os.system('rm -f %s'%config.rss_file)
#				os.system('sync')
#				os.system('sync')
#				os.system('sync')		
			cmd = 'python %s &'%(config.rss_file_get_py_file)
#			cmd = 'python %s'%(config.rss_file_get_py_file)
			cmds = cmd.strip()
			cmd = cmds.split(' ')
			print 'cmd=', cmd
			os.execlp('python', *cmd)

			'''
			cmd = 'wget2 %s -O %s -T 10 -t 1'%(config.rss_site, config.rss_file)
			cmds = cmd.strip()
			cmd = cmds.split(' ')
			print 'cmd=', cmd
			os.execlp('wget2', *cmd)
			'''
				
	def rss_file_get_exit(self):
		if self.timer != None :
			self.timer = None
		print 'die child'	
		os._exit(0)
			
	def rss_file_get_stop(self):
		try :
			if self.pid == 0 :
				return True
			print 'rss pid=', self.pid
			#os.kill(fileget_pid, signal.SIGKILL)
			os.system('kill -9 %d'%self.pid)
			os.waitpid(self.pid, 0)
			self.pid = 0
		except :
			print 'error kill rss file get process'
			pass
			

	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 rss_child_process_check(self) :
		print 'rss_process_file_check pid =', self.pid
		print 'parent pid', os.getpid()
		print 'child pid', self.pid		
		
		if self.pid != 0 :
			print 'Process still alive'
			print 'wait pid!!!!!!'
			wpid, ret = os.waitpid(self.pid, os.WNOHANG)
			print 'wait pid = ', wpid
			print 'wait pid ret = ', ret 
			if self.pid != wpid :
				if ret == 256 :
					print 'keck!!!'
					return ret
				elif wpid == 0 and ret == 0:
					procstat = self.get_proc_status()
					if procstat == 'S' or procstat == 'Z' :
						return ret
					elif procstat == 'E' :
						print 'e wait pid = ', wpid
						print 'e self.pid = ', self.pid					
						print 'e wait pid ret = ', ret
						self.pid = 0
						return 'False'
				else :
					return ret
					
			else :	
				if ret != 0 :
					self.pid = 0
					print 'wpid= %d, self pid = %d, ret=%d'%(wpid, self.pid, ret)
					return 'False'
				os.system('sync')		
				os.system('sync')
				os.system('sync')	
				self.pid = 0
				return 'True'			
		else :
			return 'True'

	def rss_file_check(self):
		if not os.access(config.rss_file, os.R_OK):
			print 'rss file check, no file!!!'
			return False
		return True	
	def rss_read(self):
		try :
			
			r = file(config.rss_file , 'r').read()
			d =eval(r)

			'''
			d = feedparser.parse(config.rss_file)
			print 'sort'
			self.rss_quick_sort(d.entries)
			print 'rss_test'
			print d.entries[0].title
			'''


#			print 'sort result!!!'
#			for i in range(len(d.entries)-1) :
#				print d.entries[i].title
#				print d.entries[i].date
#				print d.entries[i].date_parsed
#				print 'sort result finish!!!'

		except :
			print 'rss_read error'
			d = None
			pass
		return d		

# quick sort
	def rss_quick_sort(self, list2):
		self.rss_quick_sort_r(list2, 0, len(list2) - 1)		

# quick_sort_r, recursive (used by quick_sort)
	def rss_quick_sort_r(self, list2 , first, last):
		
		if last > first:
			pivot = self.rss_partition(list2, first, last)
			self.rss_quick_sort_r(list2, first, pivot - 1)
			self.rss_quick_sort_r(list2, pivot + 1, last) 

# partition (used by quick_sort_r)
	def rss_partition(self, list2, first, last):
		sred = (first + last)/2
		if time.mktime(list2[first].date_parsed) < time.mktime(list2 [sred].date_parsed):
			list2[first], list2[sred] = list2[sred], list2[first]  # swap    
		if time.mktime(list2[first].date_parsed) < time.mktime(list2 [last].date_parsed):
			list2[first], list2[last] = list2[last], list2[first]  # swap    
		if time.mktime(list2[sred].date_parsed) < time.mktime(list2[last].date_parsed):        
			list2[sred], list2[last] = list2[last], list2[sred]    # swap    
		list2 [sred], list2 [first] = list2[first], list2[sred]    # swap    
		pivot = first    
		i = first + 1    
		j = last     

		while True:
			while i <= last and time.mktime(list2[i].date_parsed) >= time.mktime(list2[pivot].date_parsed):
				i += 1        
			while j >= first and time.mktime(list2[j].date_parsed) < time.mktime(list2[pivot].date_parsed):
				j -= 1        
			if i >= j:            
				break        
			else:
				list2[i], list2[j] = list2[j], list2[i]  # swap    
		list2[j], list2[pivot] = list2[pivot], list2[j]  # swap    

		return j	



	def destroy(self):
		#RSS
		#print 'idle destroy'
		self.timer = None

class RSS_manager:
	def __init__(self):
		#rss_test MMW 2008.12.09
		self.rss_feed = None
		self.rss_count = 0
		self.rss_num = 0
		self.timer = None					# 1 sec( wait pid), 10sec (wait for data get from web), 60sec( wait network connection) 
		self.rss_data_update_timer = None	# 3 sec (every 3 sec send data to screen)
		self.periodic_update_timer = None	# 15 min, 60 min, 24 hour
		self.Rss_network_check()
	

	def Update_timer_Set(self):
		if self.periodic_update_timer != None :
			self.periodic_update_timer = None
		print 'periodic RSS update timer  set!!!!!!!!!!!!!!!!!!!!'
		self.periodic_update_timer = utils.Timer(config.rss_feed_update_time ,\
			self.start_update_Rss)

	def start_update_Rss(self):
		print 'RSS update called by periodic RSS update timer!!!!!!!!!!!!!!!!!!!!'
		status.Rss_feed_data_get = True
		self.Rss_network_check()				

		
	def Rss_network_check(self ):
		if self.timer != None :
			self.timer = None
			
		if status.network_status != status.NetOk :
			self.timer = utils.Timer(config.RSS_network_ok_wait_time,\
			self.Rss_network_check)
			self.rss_feed == None
		else :			
			if self.rss_feed == None or status.Rss_feed_data_get == True:
#				self.rss_feed = None
#				self.rss_count = 0
				self.Rss_feed_file_get()
			self.update_RSS_data()

	def Rss_feed_file_get(self):
		if self.timer != None :
			self.timer = None
		ret = RSS_Reader.rss_file_get()
		if ret == 'True':
			#10 sec timer run to check file
			self.timer = utils.Timer(config.RSS_data_check_time,\
				self.RSS_feed_file_check)
		elif ret == 'False':
			#fork error
			self.timer = utils.Timer(config.RSS_fork_error_update_time,\
				self.Rss_feed_file_get)
		else :
			#1 sec timer to wait pid
			self.timer = utils.Timer(config.RSS_wait_pid_time,\
				self.Rss_feed_file_get)
			print 'Rss_feed_file_get pid ret = 256!!!!!!!!!'

	def RSS_feed_file_check(self):
		if self.timer != None :
			self.timer = None
		ret = RSS_Reader.rss_child_process_check()	
		if ret == 'True' :
			if RSS_Reader.rss_file_check() == True:
				# parse data from /tmp/rss.xml
				print 'RSS file get success!!!'
				temp_rss_feed = RSS_Reader.rss_read() 
				if temp_rss_feed == None :
					print 'feed data None!!!'
					self.Rss_network_check()
				else :
					if self.rss_data_update_timer != None :
						self.rss_data_update_timer = None				
					#show rss data

					self.rss_feed = temp_rss_feed

					print 'rss ###################', self.rss_feed['entries'][0]['title']
					self.rss_num =  len(self.rss_feed['entries'])
					print 'how many entries this rss got', self.rss_num
					print '*****',  self.rss_feed['entries'][self.rss_num-1]['title']
					self.rss_count = 0
					self.update_RSS_data()
					status.Rss_feed_data_get = False
					self.Update_timer_Set()
			else :
				#There is No file in /tmp/rss.xml. so, start from network check 
				self.Rss_network_check(False)
		elif ret == 'False' :
			self.timer = utils.Timer(config.RSS_wait_pid_time,\
				self.Rss_network_check)
		elif ret == 512 :		# nothing to update python exit(2)
			#nothing to feed
			print 'python exit 2, nothing to update from rss site'
			status.Rss_feed_data_get = False
			self.Update_timer_Set()
		else :	# child process is alive, so wait
			# pid wait error do RSS feed file check
			self.timer = utils.Timer(config.RSS_wait_pid_time,\
				self.RSS_feed_file_check)


				

	def update_RSS_data(self):
#		print '### IdleStage.update_RSS_data() called'
		if self.rss_data_update_timer != None :
			self.rss_data_update_timer = None

		if runtime.manager.stage.get_name() != 'idle' :
			print 'Not idle, Nothing to update idle screen'
#			self.rss_data_update_timer = None
		elif runtime.myannapp != None and runtime.myannapp.is_running() :
			print 'Browser is runnig, so, Nothing to update idle screen'
		else :	
			if self.rss_feed == None :
				runtime.manager.stage.ui.update_RSS_data('Wait for RSS data')
			else :
				runtime.manager.stage.ui.update_RSS_data(self.rss_feed['entries'][self.rss_count]['title'])	
				self.rss_count = self.rss_count + 1
				if self.rss_count == self.rss_num :
					self.rss_count = 0
#			if self.timer != None :
#				self.timer = None
#			if self.rss_data_update_timer != None :
#				self.rss_data_update_timer = None
		self.rss_data_update_timer = utils.Timer(config.RSS_data_update_time,\
		self.update_RSS_data)				

	def destroy(self):
		self.timer = None
		self.rss_data_update_timer = None
		self.periodic_update_timer = None
	
RSS_Reader = RSS_reader()