import socket
import evas
import os
import signal
import sys
import utils
import ppp
import config
import runtime
from mms_net_define import *

EXPIRE_TIME_MAX = 5*60*1000
EXPIRE_TIME_ONEMIN = 60*1000

class MMSCTR_Manager:
	def __init__(self, nettype, prog_cb=None, eretrieveinfo=None):
		if DEBUG_MMS_NET:
			print 'MMSCTR_Manager.init'
		try:
			os.unlink(NMGR_SOCK_FILE)
		except OSError:
			pass
		self.m_progcb = prog_cb
		self.m_retrieveinfo = None
		if eretrieveinfo:
			self.m_retrieveinfo = list(eretrieveinfo)
		self.m_nettype = nettype
		self.m_pid = None
		self.m_error = NMGR_NOERROR
		self.m_tmpsavedmsg = None
		self.m_ppp = None
		self.ppp_max = None
		self.m_pppconnecttimer = None
		self.m_expiretimer = None
		self.m_sendmgr_s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM, 0)
		self.m_sendmgr_s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
		self.m_sendmgr_s.bind(NMGR_SOCK_FILE)
		self.m_sendmgr_s.listen(5)
		self.m_sendmgrclient_s = None
		self.m_accept_tag = None

		if DEBUG_MMS_NET:
			print 'self.m_sendmgr_s', self.m_sendmgr_s, self.m_sendmgr_s==None

		self.m_listen_tag = utils.Input(self.m_sendmgr_s.fileno(), \
			self.Accept_MSendmgr)

		self.Init_Net()

	def __del__(self):
		self.Send_Exit()

	def Close_SvrSocket(self):
		if self.m_sendmgrclient_s:
			self.m_sendmgrclient_s.close()
			self.m_sendmgrclient_s = None

		if self.m_sendmgr_s:
			self.m_sendmgr_s.close()
			self.m_sendmgr_s = None
			self.m_listen_tag = None

	def Init_Net(self):
		from profile import profile
		if 0 == profile.get_profile():
			if DEBUG_MMS_NET:
				print 'MMSCTR_Manager.Net_Init'
			self.Init_PPP()
		else:
			self.Fork_Net()
			pass

	def Expire_TimerRM(self):
		if self.m_expiretimer:
			if DEBUG_MMS_NET:
				print 'MMSCTR_Manager.Expire_TimerRM'
			runtime.evas.timeout_remove(self.m_expiretimer)
			self.m_expiretimer = None

	def Set_ExpireTimer(self, extime=EXPIRE_TIME_MAX):
		self.Expire_TimerRM()
		if DEBUG_MMS_NET:
			print 'MMSCTR_Manager.Set_ExpireTimer', extime
		self.m_expiretimer = runtime.evas.timeout_add(extime, self.Expire_TimerCb)

	def Expire_TimerCb(self):
		if DEBUG_MMS_NET:
			print 'MMSCTR_Manager.Expire_TimerCb'
		self.Expire_TimerRM()
		if NMGR_MSEND == self.m_nettype:
			self.Send_Exit()
			self.MSend_PPPErrorSave()
			self.MSendCTR_Fail()
		elif NMGR_MRETREIVE == self.m_nettype:
			self.MRetrCTR_Fail()

	def PPP_ConnecttimerRM(self):
		if self.m_pppconnecttimer:
			runtime.evas.timeout_remove(self.m_pppconnecttimer)
			self.m_pppconnecttimer = None

	def Init_PPP(self):
		self.PPP_ConnecttimerRM()

		from profile import profile
		if 0 == profile.get_profile():
			if DEBUG_MMS_NET:
				print 'MMSCTR_Manager.Init_PPP'
			self.ppp_max = runtime.evas.timeout_add(60000, self.PPP_MaxtimerCb)

			if TEST_LG_NAS:
				self.m_ppp = ppp.PPP(1)
				self.m_ppp.call_ppp(config.sac4, self.PPP_ConnectSuccessCB, self.PPP_ConnectFailCB)
			else:
				self.m_ppp = ppp.PPP(2)
				if DEBUG_MMS_NET:
					print 'config.sac5',config.sac5,type(config.sac5)
				x = '0'
				y = '5'
				from setting import setting
				mmssacnumber = config.sac5 + x + y + setting.terminal_number
				self.m_ppp.call_ppp(mmssacnumber, self.PPP_ConnectSuccessCB, self.PPP_ConnectFailCB)


	def PPP_MaxtimerRemove(self):
		if self.ppp_max:
			if DEBUG_MMS_NET:
				print 'PPP_TimerRemove'
			runtime.evas.timeout_remove(self.ppp_max)
			self.ppp_max = None

	def MSend_PPPErrorSave(self):
		if DEBUG_MMS_NET:
			print 'mms_net_ctrserver.MSend_PPPErrorSave'
		from mms_net_ctr import M_Send_CTR
		tmpsend = M_Send_CTR(False)
		self.m_error = NMGR_MNETFAIL
		try:
			self.m_tmpsavedmsg = tmpsend.Save_Message()
		except:
			self.m_error |= NMGR_SAVEFAIL

	def PPP_MaxtimerCb(self):
		if DEBUG_MMS_NET:
			print 'MMSCTR_Manager.PPP_MaxtimerCb'
		self.PPP_MaxtimerRemove()
		self.Uninit_Net()
		if NMGR_MSEND == self.m_nettype:
			self.MSend_PPPErrorSave()
			self.MSendCTR_Fail()
		else:
			self.MRetrCTR_Fail()

	def PPP_ConnectSuccessCB(self):
		if DEBUG_MMS_NET:
			print 'MMSCTR_Manager.PPP_ConnectSuccessCB'

		self.PPP_MaxtimerRemove()
		self.Fork_Net()

	def PPP_ConnectFailCB(self):
		if not self.ppp_max:
			if DEBUG_MMS_NET:
				print '## PPP_ConnectFailCB ?? ##', self.m_pid
			return
		else:
			if DEBUG_MMS_NET:
				print '## PPP_ConnectFailCB self.ppp_max ##', self.m_pid
			pass
		self.PPP_MaxtimerRemove()
		if DEBUG_MMS_NET:
			print 'MMSCTR_Manager.PPP_ConnectFailCB'
		self.Uninit_Net()
		if NMGR_MSEND == self.m_nettype:
			self.MSend_PPPErrorSave()
			self.MSendCTR_Fail()
		else:
			self.MRetrCTR_Fail()

	def Uninit_Net(self):
		from profile import profile
		if 0 == profile.get_profile() and None != self.m_ppp:
			if DEBUG_MMS_NET:
				print 'MMS_Net_BaseCTR.PPP_Close'
			self.m_ppp.stop_ppp()
			self.m_ppp = None
			self.ppp_max = None
			self.m_pppconnecttimer = None

	def Fork_Net(self):
		self.m_pid = os.fork()
		if 0 == self.m_pid:
			self.m_pid = os.getpid()
			if DEBUG_MMS_NET:
				print 'MMSCTR_Manager pid', self.m_pid

			import mms_net_ctr
			if NMGR_MSEND == self.m_nettype:
				mms_net_ctr.MSend_Client()
			elif NMGR_MRETREIVE == self.m_nettype:
				mms_net_ctr.MRetreive_Client()

			if DEBUG_MMS_NET:
				print 'Exit Fork_Net'
			sys.exit()
		else:
			self.Set_ExpireTimer(EXPIRE_TIME_ONEMIN)

	def Kill_CTR(self):
		try:
			if not self.m_pid:
				if DEBUG_MMS_NET:
					print 'kill_CTR return'
				return
			if DEBUG_MMS_NET:
				print 'kill_CTR', self.m_pid
			os.kill(self.m_pid, signal.SIGKILL)
			os.waitpid(self.m_pid, 0)
			def hdl_sigchld(signum, frame):
				try:
					while 1:
						if os.waitpid(0, os.WNOHANG): raise OSError
				except OSError:
				   	pass

			signal.signal(signal.SIGCHLD, hdl_sigchld)

			self.m_pid = None
		except:
			if DEBUG_MMS_NET:
				print 'Kill_CTR ERROR'
			pass
	def Send_Packet(self, buf):
		import struct
		p = struct.pack('B', len(buf))
		if DEBUG_MMS_NET:
			print 'svr.Send_Packet p:', p, ord(p)
		self.m_sendmgrclient_s.send(p)
		self.m_sendmgrclient_s.send(buf)
		if DEBUG_MMS_NET:
			print 'svr.Send_Packet:', buf

	def Recv_Packet(self):
		c = self.m_sendmgrclient_s.recv(1)
		packetlen = ord(c)

		msg = ''
		while packetlen > 0:
			m = self.m_sendmgrclient_s.recv(1)
			packetlen -= len(m)
			msg += m

		if DEBUG_MMS_NET:
			print '--> srv:', ord(c), ',', ord(msg[0]), ',', msg[1:]

		return msg

	def MSend_OffHook(self):
		if DEBUG_MMS_NET:
			print 'MSend_OffHook'
		self.Send_Exit()

	def End_MMSCtr(self):
		if DEBUG_MMS_NET:
			print 'End_MMSCtr'
		self.Send_Exit()
		if NMGR_MSEND == self.m_nettype:
			from mms_net_ctr import M_Send_CTR
			self.m_error = NMGR_MNETFAIL
			tmpsave = M_Send_CTR(False)
			try:
				self.m_tmpsavedmsg = tmpsave.Save_Message()
				if DEBUG_MMS_NET:
					print 'end-mmsctr', self.m_tmpsavedmsg
			except:
				self.m_error |= NMGR_SAVEFAIL

			self.MSendCTR_Fail()
		elif NMGR_MRETREIVE == self.m_nettype:
			self.MRetrCTR_Fail()

	def Accept_MSendmgr(self, fd, type):
		if DEBUG_MMS_NET:
			print 'Accept_MSendmgr. fd = %d, type = %d' % (fd, type)
		assert type == evas.INPUT_READ

		self.m_sendmgrclient_s, addr = self.m_sendmgr_s.accept()
		if DEBUG_MMS_NET:
			print 'clientsocket', self.m_sendmgrclient_s
		if NMGR_MSEND == self.m_nettype:
			self.m_accept_tag = utils.Input(self.m_sendmgrclient_s.fileno(), \
				self.Handle_MSendmgr)
		elif NMGR_MRETREIVE == self.m_nettype:
			self.m_accept_tag = utils.Input(self.m_sendmgrclient_s.fileno(), \
				self.Handle_MRetrievemgr)

		return True

	def Handle_MRetrievemgr(self, fd, type):
		if type & evas.INPUT_HUP:
			if DEBUG_MMS_NET: print 'Handle_MRetrievemgr.connection_closed'
			return False

		assert type & evas.INPUT_READ
		str = self.Recv_Packet()

		if NMGR_NOERROR == ord(str[0]):
			self.Expire_TimerRM()
			if DEBUG_MMS_NET:
				print 'Handle_MRetrievemgr.NMGR_NOERROR'
			self.m_tmpsavedmsg = str[1:]
			self.MRetrCTR_Success()
		elif NMGR_EXTEND & ord(str[0]):
			if NMGREXT_PROGRESS & ord(str[0]):
				if DEBUG_MMS_NET:
					print 'NMGREXT_PROGRESS', str[1:], int(str[1:])
				if self.m_progcb:
					self.m_progcb(str[1:])
		else:
			if NMGR_CONNECT & ord(str[0]):
				self.m_tmpsavedmsg = None
				self.m_error = NMGR_NOERROR
				if DEBUG_MMS_NET:
					print 'Handle_MRetrievemgr.NMGR_CONNECT'
					print self.m_retrieveinfo
				fname, t, isread, address, report, subject, url, transactionid, \
					mmsexpiry = self.m_retrieveinfo
				info = '%s,%s,%d,%s,%d,%s,%s,%s,%s' % \
				(fname, t, isread, address, report, unicode(subject).encode('ascii'), url, transactionid, mmsexpiry)
				self.Send_Packet(chr(NMGR_MCTRBEGIN)+info)
				self.Set_ExpireTimer()
			elif NMGR_MNETFAIL & ord(str[0]):
				self.Expire_TimerRM()
				self.m_error = ord(str[0])
				if DEBUG_MMS_NET:
					print 'Handle_MRetrievemgr.NMGR_MNETFAIL', self.m_error
				self.MRetrCTR_Success()
			elif NMGR_MMSRESULTFAIL & ord(str[0]):
				self.Expire_TimerRM()
				if DEBUG_MMS_NET:
					print 'Handle_MRetrievemgr.NMGR_MMSRESULTFAIL'
				self.m_error = ord(str[0])
				self.MRetrCTR_Success()
			elif NMGR_SAVEFAIL & ord(str[0]):
				self.Expire_TimerRM()
				if DEBUG_MMS_NET:
					print 'Handle_MRetrievemgr.NMGR_SAVEFAIL'
				self.m_error = ord(str[0])
				self.MRetrCTR_Success()
			elif NMGR_MRETREIVECOMP & ord(str[0]):
				if DEBUG_MMS_NET:
					print 'Handle_MRetrievemgr.NMGR_MRETREIVECOMP'
					print str[1:]

				tokens = str[1:].split(',', 8)
				if len(tokens) != 9:
					pass
				filename, t, isread, address, report, subject, \
					url, transactionid, mmsexpiry = tokens
				self.m_retrieveinfo[5] = subject

		return True

	def MRetrCTR_Success(self):
		if DEBUG_MMS_NET:
			print 'MRetrCtr_Success'
		self.Send_Exit()
		if DEBUG_MMS_NET:
			print 'self.m_error', self.m_error
		if NMGR_NOERROR == self.m_error:
			from mmsmanager import mmsmgr
			mmsmgr.remove_notyinfo(self.m_retrieveinfo[6])
			mmsmgr.insert_received_info(0, self.m_retrieveinfo[3], \
				self.m_retrieveinfo[5], self.m_retrieveinfo[4], self.m_retrieveinfo[6], \
				self.m_retrieveinfo[7], self.m_retrieveinfo[8], self.m_tmpsavedmsg)

			if DEBUG_MMS_NET:
				print 'MRetrCTR_Success TRUE'
			runtime.manager.stage.Exit_Stage()
		else:
			if DEBUG_MMS_NET:
				print 'MRetrCTR_Success FALSE'
			if NMGR_INCORRECT & self.m_error:
				if DEBUG_MMS_NET:
					print 'MRetrCTR_Success.NMGR_INCORRECT'
					print self.m_retrieveinfo[6]
				from mmsmanager import mmsmgr
				mmsmgr.remove_notyinfo(self.m_retrieveinfo[6])
				runtime.manager.stage.Exit_Stage(False, False, True)
				return
			if NMGR_SAVEFAIL & self.m_error:
				runtime.manager.stage.Exit_Stage(False, True)
			else:
				runtime.manager.stage.Exit_Stage(False)

	def MRetrCTR_Fail(self):
		if DEBUG_MMS_NET:
			print 'MRetrCTR_Fail'
		self.Send_Exit()
		runtime.manager.stage.Exit_Stage(False)

	def Handle_MSendmgr(self, fd, type):
		if type & evas.INPUT_HUP:
			if DEBUG_MMS_NET: print 'Handle_MSendmgr.connection_closed'
			return False

		assert type & evas.INPUT_READ
		str = self.Recv_Packet()

		if NMGR_NOERROR == ord(str[0]):
			self.Expire_TimerRM()
			self.m_tmpsavedmsg = str[1:]
			if DEBUG_MMS_NET:
				print 'Handle_MSendmgr.NMGR_NOERROR',self.m_tmpsavedmsg
			self.MSendCTR_Success()
		elif NMGR_EXTEND & ord(str[0]):
			if NMGREXT_PROGRESS & ord(str[0]):
				if DEBUG_MMS_NET:
					print 'NMGREXT_PROGRESS', str[1:], int(str[1:])
				if '100' == str[1:]:
					self.Set_ExpireTimer(EXPIRE_TIME_ONEMIN)
				else:
					self.Set_ExpireTimer(EXPIRE_TIME_ONEMIN/2)
				if self.m_progcb:
					self.m_progcb(str[1:])
		else:
			if NMGR_CONNECT & ord(str[0]):
				if DEBUG_MMS_NET:
					print 'Handle_MSendmgr.NMGR_CONNECT'
				self.m_tmpsavedmsg = None
				self.m_error = NMGR_NOERROR
				self.Send_Packet(chr(NMGR_MCTRBEGIN))
				self.Set_ExpireTimer(EXPIRE_TIME_ONEMIN)
			elif NMGR_MMSRESULTFAIL & ord(str[0]):
				self.Expire_TimerRM()
				if DEBUG_MMS_NET:
					print 'Handle_MSendmgr.NMGR_MMSRESULTFAIL'
				self.m_error = ord(str[0])
				if NMGR_SAVEFAIL & ord(str[0]):
					pass
				else:
					self.m_tmpsavedmsg = str[1:]
				self.MSendCTR_Fail()
			elif NMGR_MNETFAIL & ord(str[0]):
				self.Expire_TimerRM()
				self.m_error = ord(str[0])
				if NMGR_SAVEFAIL & ord(str[0]):
					if DEBUG_MMS_NET:
						print 'NMGR_MNETFAIL.NMGR_SAVEFAIL'
					pass
				else:
					if DEBUG_MMS_NET:
						print 'NMGR_MNETFAIL.NMGR_SAVEFAIL else'
					self.m_tmpsavedmsg = str[1:]
				self.MSendCTR_Fail()
			elif NMGR_SAVEFAIL & ord(str[0]):
				self.Expire_TimerRM()
				self.m_error = ord(str[0])
				self.MSendCTR_Success()
			else:
				if DEBUG_MMS_NET:
					print 'Handle_MSendmgr.NoCASE'
				pass
		return True

	def Send_Exit(self):
		self.Expire_TimerRM()
		self.PPP_ConnecttimerRM()
		self.PPP_MaxtimerRemove()
		if DEBUG_MMS_NET:
			print 'Send_Exit'

		self.Kill_CTR()
		self.Uninit_Net()

	def Not_SaveMessage(self):
		if DEBUG_MMS_NET:
			print 'MMSCTR_Manager.Not_SaveMessage', self.m_tmpsavedmsg
		if NMGR_NOERROR == self.m_error and self.m_tmpsavedmsg:
			os.remove(self.m_tmpsavedmsg)
		self.Send_Exit()
		pass

	def Save_MSendMessage(self, box_path=None):
		if DEBUG_MMS_NET:
			print 'Save_MSendMessage-', self.m_error
		if NMGR_SAVEFAIL & self.m_error:
			if DEBUG_MMS_NET:
				print 'Save_MSendMessage-NMGR_SAVEFAIL'
			self.Send_Exit()
			raise MemoryError
			return None
		else:
			msgsize = utils.get_file_size(self.m_tmpsavedmsg) / 1024
			if DEBUG_MMS_NET:
				print 'Save_MSendMessage.file_size', msgsize
			if not utils.check_free_storage('mms_save', msgsize):
				from basemodel import StorageFullError
				raise StorageFullError
				return

			if DEBUG_MMS_NET:
				print 'Save_MSendMessage-save', self.m_tmpsavedmsg
			fname = os.path.split(self.m_tmpsavedmsg)[1]
			if DEBUG_MMS_NET:
				print 'save_MSendMessage', box_path+fname
			systemMv = 'mv ' + self.m_tmpsavedmsg + ' ' + box_path + fname
			os.system(systemMv)
			self.Send_Exit()
			if DEBUG_MMS_NET:
				print 'return', box_path+fname

			return box_path+fname

	def MSendCTR_Success(self):
		if DEBUG_MMS_NET:
			print 'M_Send_CTR.CTR_Success'

		from mms_net_sendstage import MMS_Send_Stage
		mmssndstage = None
		if ('mmssendstage' == runtime.manager.stage.get_name()):
			mmssndstage = runtime.manager.stage
		else:
			mmssndstage = runtime.manager.find_stage('mmssendstage')

		if DEBUG_MMS_NET:
			print 'mmssndstage', mmssndstage, runtime.manager.stage.get_name()

		if mmssndstage:
			mmssndstage.Success()

		if DEBUG_MMS_NET:
			print mmssndstage == None

	def MSendCTR_Fail(self):
		if DEBUG_MMS_NET:
			print 'M_Send_CTR.CTR_Fail'
		from mms_net_sendstage import MMS_Send_Stage
		mmssndstage = None
		if ('mmssendstage' == runtime.manager.stage.get_name()):
			mmssndstage = runtime.manager.stage
		else:
			mmssndstage = runtime.manager.find_stage('mmssendstage')
		if DEBUG_MMS_NET:
			print 'mmssndstage', mmssndstage, runtime.manager.stage.get_name()

		if mmssndstage:
			mmssndstage.Fail()