from model.data import Data
from model.translation import from_container_list
from lib.snabbdom import h
import message as M
from view import View
from view.utils import show_toggle_cluster_buttons

from model.example.component_lexeme import ComponentLexeme
from model.example.corpus_example import CorpusExample
from model.example.multiword_example import MultiwordExample
from model.example_clusters import ExampleClusters


class Example(Data):
    def __init__(self):
        self.translations = []
        self.inner = None
        self.components = []
        self.edited = False
        self.newly_created = False
    
    # removes space from last component if multiword example
    def check_multiword_components(self):
        if self.is_multiword():
            self.components[len(self.components) - 1].no_space = ComponentLexeme.LAST_COMPONENT_SPACE
    
    @staticmethod
    def new_multiword():
        example = Example()
        example.newly_created = True
        example.edited = True
        example.inner = MultiwordExample()
        example.inner.cluster = ExampleClusters.first_empty_cluster()
        example.inner.type = "type??"
        
        empty_component = ComponentLexeme()
        empty_component.role = "headword"
        example.components.append(empty_component)
        
        return example
    
    def import_xml(self, example_xml):
        self.translations = from_container_list(example_xml.querySelectorAll("translationContainer"))
        
        if example_xml.hasAttribute("modified"):
            self.edited = example_xml.getAttribute("modified") == "true"
                
        inner_xml = example_xml.querySelector("corpusExample")
        if inner_xml is not None:
            self.inner = CorpusExample()
        else:
            inner_xml = example_xml.querySelector("multiwordExample") 
            self.inner = MultiwordExample()
        
        self.inner.import_xml(inner_xml)
        
        for idx, comp_xml in enumerate(inner_xml.childNodes):
            comp = ComponentLexeme()
            comp.import_xml(comp_xml)
            if comp.isValid():
                self.components.append(comp)
        
        self.check_multiword_components()
        
    def export(self, doc):
        self.check_multiword_components()
        
        result = doc.createElement("exampleContainer")
        
        inner = self.inner.export(doc, self.edited)
        # TODO: bad quick fix
        for comp in self.components:
            inner.appendChild(comp.export(doc))
        
        result.appendChild(inner)
        return result
    
    def view(self, model, sense):
        example_tag = "div.example-rest"
        if self in model.chosen_examples:
            example_tag += ".example-chosen"
                
        cluster = self.get_cluster()
        dot_attr = {"style": { "visibility": "visible" if cluster is None else "hidden"}}
        
        example_content = []
        if cluster is not None:
            example_content.append(h("span.example-cluster", {}, str(cluster + 1)))
        
        example_text_inner_tag = "span.example-text-{}".format(self.get_view_type())
        example_content.append(h(example_text_inner_tag, {}, self.inner.view(self.components)))
        
        other_attributes = self.get_other_attributes()
        if "frequency" in other_attributes:
            example_content.append(h("span.example-frequency", {}, other_attributes["frequency"]))
        if "logDice" in other_attributes:
            example_content.append(h("span.example-logdice", {}, other_attributes["logDice"]))
        
        parent_display = "none"
        if model.examples_shown or self.is_multiword() or len(self.translations) > 0:
            parent_display = "inherit"
        
        clusters_display = "inherit"
        if not model.clusters_shown:
            clusters_display = "none"
        
        return h("div.example", {"style": {"display": parent_display}}, [
          h("div.example-dot", dot_attr, "▣"),
          h(example_tag, {}, [
            h("span.example-text", {"on": {"click": M.msg(M.ShowExampleMenu, self)} }, example_content),
            h("div.example-translation-list", {}, [
              h("div.example-translation", {}, View.view_translations(self.translations, self, model))]),
            h("div.example-clusters", 
              {"style": {"display": clusters_display }}, show_toggle_cluster_buttons(sense, self))])])
    
    def simple_view(self):
        return self.inner.view(self.components)
        
    def get_cluster(self):
        return self.inner.get_cluster()
    
    def set_cluster(self, cluster):
        self.inner.cluster = cluster
    
    def get_structure(self):
        return self.inner.get_structure()
    
    def is_collocation(self):
        return self.get_view_type() == 2
    
    def is_multiword(self):
        return self.get_view_type() != 1
    
    def get_view_type(self):
        # as per the bosses, these are the rules for different colors
        if type(self.inner) is CorpusExample:
            return 1
        elif self.inner.type == "collocation":
            return 2
        else:
            return 3
    
    def get_other_attributes(self):
        return self.inner.other_attributes