from message.message import Message, ClickMessage
from browser import document, window
from model.translation import TAGS, NewTranslation


class TranslationActionMessage(ClickMessage):
    def __init__(self, event, translation):
        super().__init__(event)
        self.translation = translation
    

def get_translation_location(entry, translation):
    for si, sense in enumerate(entry.senses):
        for ci, cluster in enumerate(sense.translations):
            for ti, search_translation in enumerate(cluster):
                if search_translation == translation:
                    return (si, ci, ti), (sense, cluster)
                
        
class EditTranslation(TranslationActionMessage):
    def __init__(self, _, prop):
        self.translation, self.old_cluster_idx = prop
        
    def update_model(self, model):
        self.translation.translation = document.getElementById("etv").value;
        for tag in TAGS.keys():
            select = document.getElementById("{}-s".format(tag));
            other = document.getElementById("{}-o".format(tag));
            
            if other.value:
                self.translation.tags[tag] = other.value
            elif select.selectedIndex > 0:
                self.translation.tags[tag] = select.options[select.selectedIndex].text 
            else:
                if tag in self.translation.tags:
                    del self.translation.tags[tag]
        
        new_cluster_idx = int(document.getElementById("cluster-num").value) - 1;
        self.handle_cluster_change(new_cluster_idx, model)
    
    def handle_cluster_change(self, new_cluster_idx, model):
        if self.old_cluster_idx == new_cluster_idx:
            return
            
        # first, find out the correct sense
        for sense in model.entry.senses:
            for cidx, cluster in enumerate(sense.translations):
                for tidx, t in enumerate(cluster):
                    if t == self.translation:
                        #found, lets do whatever needs to be done
                        self.do_cluster_change(sense, cluster, cidx, tidx, new_cluster_idx)
                        # we are done, lets return
                        return
        
    def do_cluster_change(self, sense, cluster, cidx, tidx, new_cluster_idx):
        # remove the translation from the old cluster
        cluster.splice(tidx, 1)
                        
        # we maybe are creating a new cluster, handle that
        if len(sense.translations) == new_cluster_idx:
            sense.translations.append([self.translation])
        elif len(sense.translations) > new_cluster_idx:
            # lets append the translation to new cluster
            sense.translations[new_cluster_idx].append(self.translation)
        else:
            raise ValueError("Bad new cluster idx :(")
            
        # we still hols cluster reference, check if empty and remove if necessary
        # we cant do this earlier since indexes change and yeah, fun stuff
        if len(cluster) == 0:
            sense.translations.splice(cidx, 1)
            

class MoveRight(TranslationActionMessage):
    def update_model(self, model):
        (_, _, idx), (_, cluster) = get_translation_location(model.entry, self.translation)
        if idx != len(cluster) - 1:
            cluster[idx], cluster[idx + 1] = cluster[idx + 1], cluster[idx]
        model.translation = None
        
        
class MoveLeft(TranslationActionMessage):
    def update_model(self, model):
        (_, _, idx), (_, cluster) = get_translation_location(model.entry, self.translation)
        if idx != 0 and len(cluster) > 1:
            cluster[idx], cluster[idx - 1] = cluster[idx - 1], cluster[idx]
        model.translation = None
        
        
class BinTranslation(TranslationActionMessage):
    def update_model(self, model):
        (_, cidx, tidx), (sense, cluster) = get_translation_location(model.entry, self.translation)
        if len(cluster) == 1:
            # remove empty cluster
            sense.translations.splice(cidx, 1)
        else:
            cluster.splice(tidx, 1)
        model.translation = None
        

class AddTranslation(EditTranslation):
    def __init__(self, _, prop):
        self.translation = NewTranslation()
        self.old_cluster_idx = -1
        self.sense = prop
    
    def handle_cluster_change(self, new_cluster_idx, _):
        # we need to cheat here
        # sense was actually given in constructor
        # we make a dummy cluster, cluster_idx and translation_idx
        # we give a correct new_cluster_idx
        self.do_cluster_change(self.sense, [None, None], None, None, new_cluster_idx)