#!/usr/bin/env python2.5

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

""" Useful functions that shouldn't be in the UI code

fMMS - MMS for fremantle

Copyright (C) 2010 Nick Leppänen Larsson <frals@frals.se>

@license: GNU GPLv2, see COPYING file.

"""

import logging

import logging.config

logging.config.fileConfig('/opt/fmms/logger.conf')

log = logging.getLogger('fmms.%s' % __name__)

import os

import array

import re

import time

import urlparse

import subprocess

import gettext

import socket

import dbus

import fmms_config as fMMSconf

import dbhandler as DBHandler

from mms.message import MMSMessage

from mms import mms_pdu

from wappushhandler import MMSSender

#TODO: constants.py?

MSG_DIRECTION_IN = 0

MSG_DIRECTION_OUT = 1

MSG_UNREAD = 0

MSG_READ = 1

_ = gettext.gettext

gettext.bindtextdomain('fmms','/opt/fmms/share/locale/')

gettext.textdomain('fmms')

class fMMS_controller():

	def __init__(self):

		""" initialize """

		self.config = fMMSconf.fMMS_config()

		self._mmsdir = self.config.get_mmsdir()

		self._pushdir = self.config.get_pushdir()

		self._outdir = self.config.get_outdir()

		self.store = DBHandler.DatabaseHandler(self)

		self.ui = False

	def clean_url(self, url):

		m = re.search(r"http\:\/\/(?i)", url)

		if m:

			url = url.replace(m.group(0), "http://")

		return url

	def get_host_from_url(self, url):

		""" gets the hostname from an url """

		# change HTTP:// etc to lowercase because

		# havoc connector depends on it

		url = self.clean_url(url)

		if not url.startswith("http://"):

			url = "http://%s" % url

		ret = urlparse.urlparse(url)

		ret = ret[1].split(":")[0]

		return ret

	def convert_to_real_ip(self, indata):

		""" converts a ip with leading zeroes to a real ip """

		# Check if it looks like an IP

		if re.search(r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b", indata):

			ip = indata.split(".")

			dot = "."

			final = []

			for octet in ip:

				final.append(str(int(octet)))

			indata = dot.join(final)

		return indata

	def convert_timeformat(self, intime, format, hideToday=False):

		mtime = intime

		try:

			mtime = time.strptime(mtime, "%Y-%m-%d %H:%M:%S")

		except ValueError, e:

			#log.info("timeconversion stage1 failed: %s %s", type(e), e)

			try:

				mtime = time.strptime(mtime)

			except ValueError, e:

				#log.info("timeconversion stage2 failed: %s %s", type(e), e)

				pass

		except Exception, e:

			#log.exception("Could not convert timestamp: %s %s", type(e), e)

			pass

		# TODO: check if hideToday == true

		# TODO: remove date if date == today

		try:

			mtime = time.strftime("%Y-%m-%d | %H:%M", mtime)

		except:

			log.info("stftime failed: %s %s", type(e), e)

			mtime = intime

		return mtime

	def send_mms(self, to, subject, message, attachment, sender):

		try:

			sender = MMSSender(to, subject, message, attachment, sender, setupConn=True, controller=self)

		except:

			msg = "%s" % (gettext.ldgettext('hildon-common-strings', "sfil_ni_operation_failed"))

			return (-1, msg)

		try:

			(status, reason, output, parsed) = sender.sendMMS()

			if parsed == True and "Response-Status" in output:

				if output['Response-Status'] == "Ok":

					log.info("message seems to have sent AOK!")

					return (0, "OK")

			errstr = gettext.ldgettext('hildon-common-strings', "sfil_ni_operation_failed")

			message = str(status) + "_" + str(reason)

			reply = str(output)

			msg = "%s\nMMSC: %s\nBODY: %s" % (errstr, message, reply)

			return (-1, msg)

		except socket.error, exc:

			log.exception("sender failed due to connection error")

			errstr = gettext.ldgettext('hildon-common-strings', "sfil_ni_operation_failed")

			errhelp = _("Please check your settings.")

			msg = "%s\n%s\n%s" % (errstr, exc, errhelp)

			return (-1, msg)

			#raise

		except Exception, exc:

			log.exception("Sender failed.")

			msg = "%s\n%s" % (gettext.ldgettext('hildon-common-strings', "sfil_ni_operation_failed"), exc)

			return (-1, msg)

			#raise

	def decode_mms_from_push(self, binarydata):

		""" decodes the given mms """

		decoder = mms_pdu.MMSDecoder()

		wsplist = decoder.decodeCustom(binarydata)

		sndr, url, trans_id = None, None, None

		try:

			url = wsplist["Content-Location"]

			log.info("content-location: %s", url)

			trans_id = wsplist["Transaction-Id"]

			trans_id = str(trans_id)

			log.info("transid: %s", trans_id)

		except Exception, e:

			log.exception("no content-location/transid in push; aborting: %s %s", type(e), e)

			bus = dbus.SystemBus()

			proxy = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications')

			interface = dbus.Interface(proxy, dbus_interface='org.freedesktop.Notifications')

			interface.SystemNoteInfoprint(gettext.ldgettext('modest', "mail_ni_ui_folder_get_msg_folder_error"))

			raise

		try:

			sndr = wsplist["From"]

			log.info("Sender: %s", sndr)

		except Exception, e:

			log.exception("No sender value defined: %s %s", type(e), e)

			sndr = "Unknown sender"

		self.save_binary_push(binarydata, trans_id)

		return (wsplist, sndr, url, trans_id)

	def save_binary_push(self, binarydata, transaction):

		""" saves the binary push message """

		data = array.array('B')

		for b in binarydata:

			data.append(b)

		try:

			fp = open(self._pushdir + transaction, 'wb')

			fp.write(data)

			log.info("saved binary push: %s", fp)

			fp.close()

		except Exception, e:

			log.exception("failed to save binary push")

			raise

	def save_push_message(self, data):

		""" Gets the decoded data as a list (preferably from decode_mms_from_push)

		"""

		pushid = self.store.insert_push_message(data)

		return pushid

	def get_push_list(self, types=None):

		""" gets a list of all push messages """

		return self.store.get_push_list()

	def is_fetched_push_by_transid(self, transactionid):

		return self.store.is_mms_downloaded(transactionid)

	def read_push_as_list(self, transactionid):

		return self.store.get_push_message(transactionid)

	def save_binary_mms(self, data, transaction):

		dirname = self._mmsdir + transaction

		if not os.path.isdir(dirname):

			os.makedirs(dirname)

		fp = open(dirname + "/message", 'wb')

		fp.write(data)

		log.info("saved binary mms %s", fp)

		fp.close()

		return dirname

	def save_binary_outgoing_mms(self, data, transaction):

		transaction = str(transaction)

		dirname = self._outdir + transaction

		if not os.path.isdir(dirname):

			os.makedirs(dirname)

		fp = open(dirname + "/message", 'wb')

		fp.write(data)

		log.info("saved binary mms %s", fp)

		fp.close()

		return dirname

	def decode_binary_mms(self, path):

		""" decodes and saves the binary mms"""

		# Decode the specified file

		# This also creates all the parts as files in path

		log.info("decode_binary_mms running: %s", str(path))

		try:

			message = MMSMessage.fromFile(path + "/message")

		except Exception, e:

			log.exception("decode binary failed:", type(e), e)

			raise

		log.info("returning message!")

		return message

	def get_filepath_for_mms_transid(self, filename):

		return self.store.get_filepath_for_mms_transid(filename).replace("/message", "")

	def is_mms_read(self, transactionid):

		return self.store.is_message_read(transactionid)

	def mark_mms_read(self, transactionid):

		self.store.mark_message_read(transactionid)

	def store_mms_message(self, pushid, message, transactionId=None):

		if transactionId:

			message.headers['Transaction-Id'] = transactionId

		mmsid = self.store.insert_mms_message(pushid, message)

		return mmsid

	def store_outgoing_mms(self, message):

		mmsid = self.store.insert_mms_message(0, message, DBHandler.MSG_DIRECTION_OUT)

		return mmsid

	def store_outgoing_push(self, wsplist):

		pushid = self.store.insert_push_send(wsplist)

		return pushid

	def link_push_mms(self, pushid, mmsid):

		self.store.link_push_mms(pushid, mmsid)

	def get_direction_mms(self, transid):

		return self.store.get_direction_mms(transid)

	def get_replyuri_from_transid(self, transid):

		uri = self.store.get_replyuri_from_transid(transid)

		try:

			uri = uri.replace("/TYPE=PLMN", "")

			return uri

		except Exception, e:

			log.exception("failed to get replyuri, got: %s (%s)", uri, uri.__class__)

			return ""

	def get_mms_from_push(self, transactionid):

		plist = self.store.get_push_message(transactionid)

		#trans_id = plist['Transaction-Id']

		# lets reuse the transactionid we already got

		trans_id = transactionid

		pushid = plist['PUSHID']

		url = plist['Content-Location']

		from wappushhandler import PushHandler

		p = PushHandler()

		path = p._get_mms_message(url, trans_id, self)

		log.info("path: %s", path)

		message = self.decode_binary_mms(path)

		log.info("storing mms...%s", trans_id)

		mmsid = self.store_mms_message(pushid, message)

	def get_mms_attachments(self, transactionid, allFiles=False):

		return self.store.get_mms_attachments(transactionid, allFiles)

	def get_mms_headers(self, transactionid):

		return self.store.get_mms_headers(transactionid)

	def delete_mms_message(self, fname):

		fullpath = self.store.get_filepath_for_mms_transid(fname)

		if fullpath:

			fullpath = fullpath.replace("/message", "")

		else:

			fullpath = self._mmsdir + fname

		log.info("fullpath: %s", fullpath)

		if os.path.isdir(fullpath):

			log.info("starting deletion of %s", fullpath)

			filelist = os.listdir(fullpath)

			log.info("removing: %s", filelist)

			for fn in filelist:

				try:

					fullfn = fullpath + "/" + fn

					os.remove(fullfn)

				except:

					log.info("failed to remove: %s", fullfn)

			try:

				log.info("trying to remove: %s", fullpath)

				os.rmdir(fullpath)

			except OSError, e:

				log.exception("failed to remove: %s %s", type(e), e)

				raise

		self.store.delete_mms_message(fname)

	def delete_push_message(self, fname):

		fullpath = self.store.get_filepath_for_push_transid(fname)

		if not fullpath:

			fullpath = self._pushdir + fname

		log.info("fullpath: %s", fullpath)

		if os.path.isfile(fullpath):

			log.info("removing: %s", fullpath)

			try:

				os.remove(fullpath)

			except Exception, e:

				log.exception("%s %s", type(e), e)

				raise

		self.store.delete_push_message(fname)

	def wipe_message(self, transactionid):

		self.delete_mms_message(transactionid)

		self.delete_push_message(transactionid)

	def save_draft(self, rcpt, text, attachment):

		if not rcpt:

			rcpt = ""

		if not text:

			text = ""

		if not attachment:

			attachment = ""

		self.store.save_draft(rcpt, text, attachment)

	def get_draft(self):

		return self.store.get_draft()

	def validate_phonenumber_email(self, nr):

		nr = str(nr)

		nr = nr.replace("+", "")

		nr = nr.replace(" ", "")

		if re.search(r"(\D)+", nr) == None or "@" in nr or ";" in nr:

			return True

		else:

		 	return False

	def get_mcc_mnc(self):

		""" Gets the SIM cards MMC/MNC """

		bus = dbus.SystemBus()

		phone = dbus.Interface(bus.get_object("com.nokia.phone.SIM", "/com/nokia/phone/SIM"), "Phone.Sim")

		hplmn = phone.read_hplmn()

		(mcc, thirdbytes, mnc) = hplmn[0]

		# extract 4 lowest bits (as integer)

		mcc1 = int(mcc) & 0xF

		# and 4 highest bits (as integer)

		mcc2 = int(mcc) >> 4

		# 4 lowest bits of the "united" byte is mcc3

		mcc3 = int(thirdbytes) & 0xF

		# 4 lowest bits of mnc is mnc1

		mnc1 = int(mnc) & 0xF

		# 4 highest bits of mnc is mnc2

		mnc2 = int(mnc) >> 4

		# if 4 highest bits of "united" byte is

		# 0xf only 2 digits are used for mnc

		mnc3 = int(thirdbytes) >> 4

		if mnc3 == 0xf:

			final_mnc = "%s%s" % (mnc1, mnc2)

		else:

			final_mnc = "%s%s%s" % (mnc1, mnc2, mnc3)

		final_mcc = "%s%s%s" % (mcc1, mcc2, mcc3)

		return final_mcc, final_mnc

	def get_current_connection_iap_id(self):

		bus = dbus.SystemBus()

		icd = dbus.Interface(bus.get_object("com.nokia.icd", "/com/nokia/icd"), "com.nokia.icd")

		(iap, ign, ign, ign, ign, ign, ign) = icd.get_statistics()

		return iap

	def disconnect_current_connection(self):

		args = "DISCONNECT"

		retcode = subprocess.call(["/opt/fmms/fmms_magic", args])

	def get_operator_display_name(self):

		bus = dbus.SystemBus()

		phone = dbus.Interface(bus.get_object("com.nokia.phone.SIM", "/com/nokia/phone/SIM"), "Phone.Sim")

		(providername, ign, ign2, err) = phone.get_service_provider_name()

		return providername

	def get_settings_from_file(self, mcc, mnc, displayname):

		fn = open("/etc/operator_settings", 'r')

		mcc = str(int(mcc))

		mnc = str(int(mnc))

		for line in fn:

			"""

			0 : MCC

			1 : MNC

			2 : SERVICE PROVIDER NAME

			3 : ACCESS TYPE

			4 : IAP NAME

			5 : GPRS ACCESSPOINT NAME

			6 : GPRS AUTOLOGIN (X = YES)

			7 : USERNAME

			8 : PASSWORD

			9 : <empty>

			10 : <empty>

			11 : GPRS MMS/WAP GATEWAY PROXY

			12 : GPRS MMS/WAP GATEWAY PORT

			13 : IP ADDRESS (IF NOT FETCHED FROM SERVER)

			14 : PRIMARY DNS ADDRESS (IF NOT FETCHED FROM SERVER)

			15 : SECONDARY DNS ADDRESS (IF AVAILABLE)

			16 : <empty>

			"""

			row = line.split('\t')

			if row[0] == mcc and row[1] == mnc and row[3] == 'MMS' and displayname.lower() in row[2].lower():

				settings = {}

				settings['apn'] = row[5]

				settings['user'] = row[7]

				settings['pass'] = row[8]

				settings['proxy'] = row[11]

				settings['proxyport'] = row[12]

				settings['ip'] = row[13]

				settings['pdns'] = row[14]

				settings['sdns'] = row[15]

				settings['mmsc'] = row[17]

				return settings

		return None

	def get_apn_settings_automatically(self):

		(mcc, mnc) = self.get_mcc_mnc()

		operatorname = self.get_operator_display_name()

		settings = self.get_settings_from_file(mcc, mnc, operatorname)

		if self.are_we_tele2_se(mcc, mnc, operatorname):

			settings = self.are_we_tele2_se(mcc, mnc, operatorname)

		log.info("Settings loaded automatically. MCC: %s MNC: %s Operatorname: %s" % (mcc, mnc, operatorname))

		log.info("Settings loaded automatically: %s" % settings)

		return settings

	def are_we_tele2_se(self, mcc, mnc, operatorname):

		mcc = str(int(mcc))

		mnc = str(int(mnc))

		if mcc == "240" and mnc == "7":

			if "Tele2" in operatorname:

				settings = {}

				settings['apn'] = "internet.tele2.se"

				settings['user'] = ""

				settings['pass'] = ""

				settings['proxy'] = "130.244.202.30"

				settings['proxyport'] = "8080"

				settings['mmsc'] = "http://mmsc.tele2.se"

				settings['pdns'] = "0.0.0.0"

				settings['sdns'] = "0.0.0.0"

				settings['ip'] = "0.0.0.0"

				return settings

		return False

	def reset_all_settings(self):

		self.config.reset_all_settings()

class Locker:

	def __init__(self, fn):

		self.fn = fn

		self.fd = None

		self.pid = os.getpid()

		self.failcounter = 0

	def lock(self):

		try:

			self.fd = os.open(self.fn, os.O_CREAT | os.O_EXCL | os.O_RDWR)

			os.write(self.fd, "%d" % self.pid)

			return 1

		except OSError:

			# we failed to lock

			self.fd = None

			self.failcounter += 1

			# after 5 unsuccessful locks we check the owner

			# is still alive

			if self.failcounter > 4:

				pid = open(self.fn, 'r').read()

				try:

					os.kill(int(pid), 0)

				except OSError, e:

					# no such process, remove the lock

					os.remove(self.fn)

			return 0

	def unlock(self):

		if not self.fd:

			return 0

		try:

			os.close(self.fd)

			os.remove(self.fn)

			return 1

		except OSError:

			return 0

	def __del__(self):

		# deconstructor, make sure lock is released

		self.unlock()

if __name__ == '__main__':

	c = fMMS_controller()