#! /usr/bin/python
# -*- coding: utf-8 -*-

from meanings.models import LexicalUnit, Synset
from connections.models import POS


class Meaning:

    def __init__(self, id, name, variant, luid, gloss, sid):
        self._id = id
        self._name = name
        self._variant = variant
        self._luid = luid
        self._gloss = gloss
        self._sid = sid

    @classmethod
    def fromTree(cls, meaning_tree):
        id = meaning_tree._attrs['xml:id']
        name = meaning_tree._children[0]._children[0]._content
        variant = meaning_tree._children[1]._children[0]._content
        luid = int(meaning_tree._children[2]._children[0]._attrs['value'])
        if len(meaning_tree._children) == 4:
            gloss = ""
            sid = int(meaning_tree._children[3]._children[0]._attrs['value'])
        elif len(meaning_tree._children) == 5:
            gloss = meaning_tree._children[3]._children[0]._content
            sid = int(meaning_tree._children[4]._children[0]._attrs['value'])
        else:
            raise UnknownError
        return cls(id, name, variant, luid, gloss, sid)

    def getId(self):
        return self._id
    
    def save(self, pos):
        synset = Synset(id=self._sid)
        synset.save()
        unit = LexicalUnit(entry=None,
                           base=self._name,
                           sense=self._variant,
                           pos=pos,
                           synset=synset,
                           text_rep=str(self))
        unit.save()
    
    def assign_entry(self, entry):
        #print('ASSIGNING ENTRY FOR:', self._name, self._variant, type(self._luid))
        luid = self._luid if self._luid > 0 else None
        #for unit in LexicalUnit.objects.filter(base=self._name, sense=self._variant, luid=luid):
        #    print(unit, unit.pos, unit.luid)
        unit = LexicalUnit.objects.get(base=self._name, sense=self._variant, luid=luid)
        unit.entry = entry
        unit.gloss = self._gloss
        unit.save()
    
    def store(self, entry, frame):
        #print(self._name, self._variant, self._luid)
        luid = self._luid if self._luid > 0 else None
        units = LexicalUnit.objects.filter(base=self._name, sense=self._variant, luid=luid)
        if len(units) == 0:
            synset = Synset(id=self._sid)
            synset.save()
            print('******', self._name, self._variant, entry.pos.tag)
            unit = LexicalUnit(entry=None, #entry=entry, KK: LUs should be assigned to entry at Entry level
                               base=self._name,
                               sense=self._variant,
                               pos=entry.pos.tag,
                               synset=synset,
                               text_rep=str(self))
            unit.save()
            1/0
        else:
            try:
                assert(len(units) == 1)
            except:
                print(entry)
                for unit in units:
                    print(unit, '*', unit.pos, '*', unit.luid)
                raise
            unit = units[0]
            # KK: LUs should be assigned to entry at Entry level
            #unit.entry = entry
            #unit.save()
        frame.lexical_units.add(unit)

    def get(self):
        units = LexicalUnit.objects.filter(base=self._name, sense=self._variant)
        if len(units) == 0:
            print(self)
            raise UnknownError()
        else:
            return units[0]
        
    def __unicode__(self):
        return '\'' + self._name + '\'-' + self._variant
    
    def __str__(self):
        return self._name + '-' + self._variant

class Meanings:

    def __init__(self, meanings):
        self._meanings = meanings

    @classmethod
    def fromTree(cls, meanings_tree):
        meanings = {}
        for subtree in meanings_tree._children[0]._children[0]._children:
            meaning = Meaning.fromTree(subtree)
            meanings[meaning.getId()] = meaning
        return cls(meanings)

    def getMeanings(self):
        return self._meanings

    def locate(self, meaning_id):
        if meaning_id in self._meanings:
            return self._meanings[meaning_id]
        else:
            return None
    
    def __str__(self):
        return '[' + ','.join([str(meaning) for meaning in self._meanings.values()]) + ']'