#!/bin/env python
import sys
import os
import dbus
import random
import time
import speechd
import commands
#import csnd
from dict import Dict
from dict import Word

# My class for key detection
class _Getch:
	"""Gets a single character from standard input.  Does not echo to the screen."""
	def __init__(self):
		try:
			self.impl = _GetchWindows()
		except ImportError:
			self.impl = _GetchUnix()

	def __call__(self): return self.impl()

class _GetchUnix:
	def __init__(self):
		import tty, sys

	def __call__(self):
		import sys, tty, termios
		fd = sys.stdin.fileno()
		old_settings = termios.tcgetattr(fd)
		try:
			tty.setraw(sys.stdin.fileno())
			ch = sys.stdin.read(1)
		finally:
			termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
		return ch

class _GetchWindows:
	def __init__(self):
		import msvcrt

	def __call__(self):
		import msvcrt
		return msvcrt.getch()

class Listenspell():

	def __init__(self, SQLiteDB):

		self.skill_level = 0
		self.level_threshold = 5
		self.points = 0
		self.words_played = 0
		self.words_correct = 0
		self.speechd_init = False
		self.dict_obj = Dict(SQLiteDB)	#Always intitiate first Dict object then Word object
		self.word_obj = Word()


	def play_sound(self,event):

		#file= event + '.wav'
		#from wave import open as waveOpen
		#from ossaudiodev import open as ossOpen
		#s = waveOpen(file,'rb')
		#(nc,sw,fr,nf,comptype, compname) = s.getparams( )
		#dsp = ossOpen('/dev/dsp','w')
		#try:
			#from ossaudiodev import AFMT_S16_NE
		#except ImportError:
			#if byteorder == "little":
				#AFMT_S16_NE = ossaudiodev.AFMT_S16_LE
			#else:
				#AFMT_S16_NE = ossaudiodev.AFMT_S16_BE
		#dsp.setparameters(AFMT_S16_NE, nc, fr)
		#data = s.readframes(nf)
		#s.close()
		#dsp.write(data)
		#dsp.close()

		os.popen("aplay --quiet " + event + ".wav")
		#if event == "begin":
			#os.popen("aplay --quiet begin.wav")
		#elif event == "correct":
			#os.popen("aplay --quiet correct.wav")
		#elif event == "incorrect":
			#os.popen("aplay --quiet incorrect.wav")

	def set_skill_level(self,level):
		self.skill_level = level

	def get_skill_level(self):
		return self.skill_level

	def get_words_played(self):
		return self.words_played

	def get_words_correct(self):
		return self.words_correct

	def get_points(self):
		return self.points

	def ans_correct(self, wordid):
		self.play_sound("correct")
		self.points = self.points + self.skill_level
		self.words_correct = self.words_correct + 1
		self.word_obj.update_score(wordid)

	def ans_incorrect(self, wordid):
		self.play_sound("incorrect")
		self.word_obj.update_score(wordid, "incorrect")

	def clear_screen(self,numlines=100):
		"""Clear the console.
        numlines is an optional argument used only as a fall-back.
        """
		import os
		if os.name == "posix":
			# Unix/Linux/MacOS/BSD/etc
			os.system('clear')
		elif os.name in ("nt", "dos", "ce"):
			# DOS/Windows
			os.system('CLS')
		else:
			# Fallback for other operating systems.
			print '\n' * numlines 

	def load_wordid(self, num_words):
		temp_list = []
		self.wordid_list = []
		temp_list = self.dict_obj.get_random_wordid(length = self.skill_level,numwords = num_words)
		for(wordid, ) in temp_list:
			self.wordid_list.append(wordid)
		return self.wordid_list

	def get_word_info(self,wordid, attribute):
		if self.word_obj.get_wordid() != wordid:
			self.word_obj.__init__(identifier = "wordid", value= wordid)
			self.words_played = self.words_played + 1

		if attribute == "def":
			return self.word_obj.get_def()
		elif attribute == "usage":
			return self.word_obj.get_usage()
		elif attribute == "word":
			return self.word_obj.get_word()  
		elif attribute == "phnm":
			phnm = self.word_obj.get_phoneme()
			if phnm == None:
				phnm = self.get_phoneme(self.word_obj.get_word())
				return phnm
			else:
				(phoneme, is_correct) = phnm
				return phoneme
		else: return False
		
	def get_phoneme(self, word = None):
		if word == None:
			return False
		phnm = commands.getoutput("/usr/bin/espeak -q -x " + word)
		self.word_obj.update_phoneme(phnm)
		return phnm
		
	def start_speechd(self):  
		try:
			self.client = speechd.SSIPClient('spd-test')
			self.client.set_output_module('espeak')
			self.client.set_language('en')
			self.client.set_punctuation(speechd.PunctuationMode.SOME)
			self.speech_state = None
		except dbus.exceptions.DBusException:
			print "Speech Dispatcher is not turned on."
			return False
		
	def callback(self,callback_type):
		self.speech_state = callback_type

	def say_text(self, text, wait= True, is_phoneme = False):
		#wait: to wait for the text to be spoken or not
		#os.popen("espeak " + text)
		if self.speechd_init == False:
			if self.start_speechd() == False:
				return False
			self.speechd_init = True

		text = str(text)
		if is_phoneme:
			text = "[" + text + "]"
		
		self.client.speak(text, callback=self.callback,event_types=(speechd.CallbackType.BEGIN, 
														speechd.CallbackType.CANCEL,
														speechd.CallbackType.END))
		if wait == True:
			while(self.speech_state != "end"):
				time.sleep(1)
			
	

	def get_key(self):
		for longestinput in range(15):
			inkey = _Getch()
			for i in xrange(sys.maxint):
				k=inkey()
				if k<>'':break
				elif k == '\r': break
			return k

	def exit_game(self):
		self.say_text("goodbye")
		self.client.close()
		sys.exit()