#!/bin/env python
import sys
import random
import sqlite3
# Provides the API to control the dictionary.

global __debug
__debug = True


class Dict:

	def __init__(self, sqliteDB = None):

		if sqliteDB == None:
			return False
		global DBname
		DBname = sqliteDB
		self.conn = sqlite3.connect(sqliteDB, isolation_level=None)
		# Turn on autocommit mode
		# Set isolation_level to "IMMEDIATE"
		self.conn.isolation_level = "IMMEDIATE"
		self.cur = self.conn.cursor()
		self.num_words = -1
		self.wordid_list = []
		self.length = 0

	def get_num_words(self, length = 0):
		if self.num_words == -1:
			if length == 0:
				self.cur.execute("SELECT COUNT(wordid) from las_word")
			else:
				self.cur.execute("SELECT COUNT(wordid) from las_word where length = ?", (length, ))
			self.num_words = self.cur.fetchone()
		return self.num_words


	def get_random_wordid(self, length=0, numwords = 1):
		if self.wordid_list == [] or self.length != length:
			if length == 0:
				self.cur.execute("SELECT wordid from las_word")
			else:
				self.length = length
				self.cur.execute("SELECT wordid from las_word where length = ?", (length, ))
			self.wordid_list = self.cur.fetchall()
		#count = self.wordid_list.count
		#count = len(self.wordid_list)
		
		randids = random.sample(self.wordid_list , numwords)
		return randids
	
	def get_DB_name(self):
		return 

class Word:

	def __init__(self, identifier=None, value= None):
		
		self.conn = sqlite3.connect(DBname, isolation_level=None)
		# Turn on autocommit mode
		# Set isolation_level to "IMMEDIATE"
		self.conn.isolation_level = "IMMEDIATE"
		self.cur = self.conn.cursor()
		if identifier == "las_word_id":
			self.las_word_id = value
			self.cur.execute("SELECT * from las_word where laswid = ?", (value,))
		elif identifier == "wordid":
			self.wordid = value
			self.cur.execute("SELECT * from las_word where wordid = ?", (value,))
		elif identifier == "word":
			self.word = value
			self.cur.execute("SELECT * from las_word where lemma = ?", (value,))
		elif identifier == None or value == None:
			self.las_word_id = None
			self.wordid = None
			self.word = None
			self.length = None
			self.synsetid_list = []
			return None
		else:
			return "Invalid Usage"

		(laswid, wordid, lemma, length) = self.cur.fetchone()
		self.las_word_id = laswid
		self.wordid = wordid
		self.word = lemma
		self.length = length
		self.synsetid_list = []

	def get_word(self):
		return self.word

	def get_wordid(self):
		return self.wordid
	
	def get_category(self, categoryid):
		self.category_list = []
		self.cur.execute("SELECT * from las_categorydef where categoryid = ?", (categoryid,))
		(categoryid, name, pos) = self.cur.fetchone()
		return name


	def get_synsetid(self):
		self.cur.execute("SELECT * from las_sense where wordid = ?", (self.wordid,))
		for (wordid, synsetid, rank) in self.cur:
			self.synsetid_list.append(synsetid)
		return self.synsetid_list

	
	def get_def(self):
		self.def_list = []
		if self.synsetid_list == []:
			self.get_synsetid()
		for synsetid in self.synsetid_list:
			self.cur.execute("SELECT * from las_synset where synsetid = ?", (synsetid,) )
			for (synsetid, pos, categoryid,	definition) in self.cur:
				cat_name = self.get_category(categoryid)
				self.def_list.append((pos, definition, cat_name))
		return self.def_list

	def get_usage(self):
		if self.synsetid_list == []:
			self.get_synsetid()
		self.usage_list = []
		for synsetid in self.synsetid_list:
			self.cur.execute("SELECT * from las_sample where synsetid = ?", (synsetid,))
			for (synsetid, sampleid, sample) in self.cur:
				self.usage_list.append((sample))
		return self.usage_list

	def update_score(self, wordid, action = "correct"):
		if action == "correct":
			try:
				self.cur.execute("SELECT * from las_score where wordid = ?", (wordid,))
				(wordid, num_played, num_correct) = self.cur.fecthone()
				num_played = num_played + 1
				num_correct = num_correct + 1
				self.cur.execute("UPDATE las_score SET num_played = ? , num_correct = ? where wordid = ?", (num_played, num_correct, wordid,))
			except :
				self.cur.execute("INSERT into las_score (wordid, num_played, num_correct) VALUES (?,?,?) ", (wordid,1,1, ))
		elif action == "incorrect":
			try:
				self.cur.execute("SELECT * from las_score where wordid = ?", (wordid,))
				(wordid, num_played, num_correct) = self.cur.fecthone()
				num_played = num_played + 1
				self.cur.execute("UPDATE las_score SET num_played = ? where wordid = ?", (num_played, wordid,))
			except :
				self.cur.execute("INSERT into las_score (wordid, num_played) VALUES (?,?) ", (wordid,1, ))
		self.conn.commit()

	
	
	
	def get_phoneme(self):
		self.cur.execute("SELECT * from las_phoneme where wordid = ?", (self.wordid,))
		t = self.cur.fetchone()
		if t != None:
			(wordid, phoneme, num_syllabe, is_correct) = t
			return (phoneme, is_correct)
		else:return None
	
	def update_phoneme(self, phoneme, is_correct = True):
		#print phoneme
		try:
			if is_correct == True:
				self.cur.execute("UPDATE las_phoneme SET phoneme = ?, is_correct = ? where wordid = ?", (phoneme, 1, self.wordid,))
			else:
				self.cur.execute("UPDATE las_phoneme SET phoneme = ?, is_correct = ? where wordid = ?", (phoneme, 0, self.wordid,))
		except:
			if is_correct == True:
				self.cur.execute("INSERT into las_phoneme (wordid, phoneme, is_correct ) VALUES (?,?,?) ", (self.wordid, phoneme, 1, ))
			else:
				self.cur.execute("INSERT into las_phoneme (wordid, phoneme, is_correct ) VALUES (?,?,?) ", (self.wordid, phoneme, 0, ))
		self.conn.commit()
		
if __name__ == "__main__":
	k = Dict()
	num_words = k.get_num_words()
	print num_words

	id = k.get_random_wordid(length = 5, numwords = 3) #will return word of length 5
	for (wordid,) in id:
		print wordid
		l = Word("wordid", wordid )

		print l.get_word()
		print l.get_def()
		print l.get_usage()