# -*- encoding: koi8-r -*-

from roxiadebug import *
#from phonedb import phonedb
import runtime

INDEX, NAME, MELODY = range(3)
record = 'index', 'name', 'melody'

class NamedListMetaClass(type):
	def __init__(cls, cls_name, bases, attrs):
		# cls -> cls_name을 갖는 class
		members = attrs['members']
		member_list = members.split()
		setattr(cls, '__slots__', ())
		def property_factory(index):
			def property_get(self):
				return self[index]
			def property_set(self, v):
				self[index] = v
			return property_get, property_set
		for i, member in enumerate(member_list):
			setattr(cls, member, property(*property_factory(i)))
		super(NamedListMetaClass, cls).__init__(cls_name, bases, attrs)
	def __call__(self, *args):
		# self: class
		instance = super(NamedListMetaClass, self).__call__(args)
		return instance

class GroupItem(list):
	__metaclass__ = NamedListMetaClass
	members = 'index name melody'
	def __init__(self, args):
		if not args:
			list.__init__(self, [''] * len(self.members.split()))
		elif len(args) == 1:
			list.__init__(self, *args)
		else:
			list.__init__(self, args)
	def is_valid(self):
		return self[0] or self[1]

class GroupDB:
	def __init__(self):
		self.db = []
		try:
			self.load_db()
		except:
			pass
			
	def new_item(self, item=None):
		if item: GroupItem(item)
		return GroupItem()

	def get_item(self, i):
		return self.db[i]
		
	def is_empty(self):
		return len(self.db) == 0

	def count(self):
		return len(self.db)

	def set_name(self, index, name):
		item = self.db[index]
		item[NAME] = name
		self.save()

	def set_melody(self, index, path='', name=''):
		item = self.db[index]
		if path != '' and name != '':
			path = path.split('/usr/local/lgvp/')[1]
			item[MELODY] = path + name
		else:
			item[MELODY] = ''
		self.save()
	
	def check_name(self, name):
		for item in self.db:
			if name == item[NAME]:
				return False
		return True
	
	def get_group_index(self, name):
		for item in self.db:
			if name == runtime.evas.pre_parse(item[NAME]):
				return item[INDEX]
		return 0 # default group index =0

	# KA: [20080428] groupdb count members
	def get_group_len(self):
		return len(self.db)

	def get_group_total_members(self):
		num = len(self.db)
		count =[]
		for i in range(num):
			from phonedb import phonedb
			_count = phonedb.get_group_number_of_members(i)
			count.append(_count)
		return count
	# KA: [20080428] groupdb count members
	
	def get_group_list(self):
		names = []
		for item in self.db:
			names.append(item[NAME])
		return names
		
	def get_name(self, index):
		if index < 0:
			return ''
		item = self.db[index]
		return item[NAME]
		
	def get_melody(self, index):
		item = self.db[index]
		return item[MELODY]

	def get_melody_dir(self, index):
		#audio_dirs = [_('None'), _('Basic bell'), _('Sweet bell'), _('Merry bell'), _('Classic bell'), _('Effect bell'), _('Download bell'), _('Recorded bell')]
		audio_dirs = [_('None'), _('Basic bell'), _('Sweet bell'), _('Merry bell'), _('Classic bell'), _('Effect bell')]
		
		item = self.db[index]
		if item[MELODY]:

			if item[MELODY].startswith('audios/audios/recorded'):
				index = 7
			else:
				path = item[MELODY].split('audios/ring/')[1]
				if path.startswith('Basic'):
					index = 1
				elif path.startswith('Sweet'):
					index = 2
				elif path.startswith('Merry'):
					index = 3
				elif path.startswith('Classic'):
					index = 4
				elif path.startswith('Effect'):
					index = 5
				elif path.startswith('download'):
					index = 6
				else:
					index = 0
			print '[groupDB] get_melody_dir=', index
			return index
		else:
			return 0
		

	def get_melody_file(self, index):		
		item = self.db[index]
		melody_name = item[MELODY]
		slash = item[MELODY].rfind('/')
		if slash >=0:
			melody_name = item[MELODY][slash+1:]
		if config.mmi_debug: print '[groupDB] get_melody_file=', melody_name		
		#dot = melody_name.rfind('.')
		#if dot >= 0:
		#	melody_name = melody_name[:dot]
		return melody_name


	def check_index(self):
		index = []
		for item in self.db:
			index.append(int(item[INDEX]))
		index.sort()
		max_index = index[len(index)-1]
		return max_index+1
	
	def insert_item(self, name , melody):
		item = self.new_item()
		# index 중복 체크
		index = self.check_index()
		item[INDEX] = str(index)
		item[NAME] = name
		item[MELODY] = melody
		try:
			assert len(item) == 3
		except:
			try:
				import traceback
				traceback.print_exc()
			except:
				pass
			return
		self.db.append(item)
		#if item[SNAPSHOT]:
		#	snapshot = item[SNAPSHOT]
		#	item[SNAPSHOT] = ''
		#	self.update_snapshot(item, snapshot)
		self.sort()
		self.save()

	def remove(self, index):
		#assert 0 <= index < len(self.db)
		item = self.db[index]
		#if item[SNAPSHOT]:
		#	self.update_snapshot(item, '')
		del self.db[index]
		self.save()

	def sort(self):
		def sort_func(x, y):
			xname = int(x[0])
			yname = int(y[0])
			return cmp(xname, yname)
		self.db.sort(sort_func)

	def load_db(self):
		import os
		modifyed = False

		for line in file('group.txt'):
			try:
				item = line[:-1].split('\t')
				if item[MELODY] != '':
					melody_file = config.audio_root_dir + item[MELODY]
					if not os.access(melody_file, os.F_OK):
						item[MELODY] = ''
						modifyed = True
				self.db.append(item)
			except:
				pass
		self.sort()
		if modifyed==True:
			self.save()

	def valid_check(self):
		import os
		modify = False
		for item in self.db:
			if item[MELODY] != '':
				melody_file = config.audio_root_dir + item[MELODY]
				if not os.access(melody_file, os.R_OK):
					item[MELODY] = ''
					modify = True
		if modify == True:
			self.sort()
			self.save()

	def save(self):
		fp = open('group.txt','w')
		for item in self.db:
			fp.write('\t'.join(item) + '\n')

	def reset(self):		
		remains = []
		for item in self.db:
			if int(item[INDEX]) in range(config.group_minimum_db):
				remains.append(item)
		self.db = remains
		self.save()

	def __del__(self):
		pass
		#print 'phonedb destroy'


groupdb = GroupDB()
if __name__ == '__main__':	
	groupdb.save()