from message.simple_messages import ClickMessage, DataChgClickMessage
from message.message import msg, Message
from view import modals
from browser import window, document
from lib.snabbdom import h

from model.example.example import Example
from model.example.corpus_example import CorpusExample
from model.example.multiword_example import MultiwordExample
from model.example.component_lexeme import ComponentLexeme


class SkeExample:
    def __init__(self, line):
        self.left = ""
        self.right = ""
        self.mid = ""
        
        for left_el in line.Left:
            self.left += left_el.str
        
        for right_el in line.Right:
            self.right += right_el.str
        
        for mid_el in line.Kwic:
            self.mid += mid_el.str
        
    def view(self):
        return [h("span", {}, self.left + " "),
                h("span", {"style": {"font-weight": "bold"}}, self.mid),
                h("span", {}, self.right)]
    
    
class SkeCollocation:
    def __init__(self, data):
        self.word = data.word
        self.frequency = data.count
        self.structure_name = data.gramrel 
        
        self.other = {"score": data.score, "cm": data.cm}

    def view(self):
        return [
            h("span.grey1", {}, self.word),
            h("span", {}, ","),
            h("span.grey2", {}, self.frequency),
            h("span", {}, ","),
            h("span.grey1", {}, self.other["score"]),
            h("span", {}, ","),
            h("span.grey2", {}, self.other["cm"]),
            h("span", {}, ","),
            h("span.grey1", {}, self.structure_name)]
    

def get_parser(ske_index_type):
    if ske_index_type == 0:
        return lambda data: [SkeExample(line) for line in data.Lines]
    elif ske_index_type == 1:
        return lambda data: [SkeCollocation(item) for item in data.Items]
    else:
        raise "unknown ske index type"


class SkeModal(ClickMessage):
    def on_event(self, event):
        # event could be data if this is the return from external library
        if type(event) in [list, int]:
            self.add_arg(event)
        else:
            if len(self._args) < 3:
                self.add_arg(None)
            super().on_event(event)
        
    def update_model(self, model):
        search_term = self.get_arg(0, str)
        ske_index = self.get_arg(1, int)
        ske_lookup = model.ske.url_for_kind_index(ske_index)
        
        # could be none if empty
        data = self.get_arg(2)
        if data is None:
            model.ske.request(search_term,
                              msg(SkeModal, search_term, ske_index), 
                              ske_lookup,
                              {"additional_refs": "s.id,p.id",
                               "error_callback": msg(SkeModal, search_term, ske_index),
                               "data_parser": get_parser(ske_index)})
            
        model.modal_set(lambda: modals.ske_list(search_term, data, model.entry.senses, model.ske.request_kinds))
    
    def reset(self):
        return False


class ShowSkeModal(SkeModal):
    def on_event(self, event):
        # if just showing first time, than show empty results and let user click search
        self.add_arg("")
        super().on_event(event)


class SearchInSkeModal(SkeModal):
    def on_event(self, event):
        self.add_arg(document.getElementById("ske-search").value)
        self.add_arg(document.getElementById("ske-select").selectedIndex)
        super().on_event(event)


class SkeInsert(DataChgClickMessage):
    def update_model(self, model):
        data = self.get_arg(0)
        
        if type(data) is not list:
            return
        
        if len(data) == 0:
            return
        
        sense_num = document.getElementById("ske-sense-select").selectedIndex
        sense = model.entry.senses[sense_num]
        
        elements = document.getElementsByClassName("ske-line-check")
        assert(len(elements) == len(data))
        
        for ex, element in zip(data, elements):
            if not element.checked:
                continue
        
            elif isinstance(ex, SkeExample):
                sense.examples.append(self._as_corpus_example(ex))
        
            elif isinstance(ex, SkeCollocation):
                sense.examples.append(self._as_multiword_example(ex))
            
            else:
                console.log("You really should not be here, my lady")
                continue
    
    def _as_corpus_example(self, example):
        new_example = Example()
        new_example.inner = CorpusExample()
        
        lex_left = ComponentLexeme()
        lex_left.text = example["left"]
        lex_left.role = None
        
        lex_mid = ComponentLexeme()
        lex_mid.text = example["mid"]
        lex_mid.role = "headword"
        
        lex_right = ComponentLexeme()
        lex_right.text = example["right"]
        lex_right.role = None
        
        new_example.components.extend([lex_left, lex_mid, lex_right])
        return new_example
        
    def _as_multiword_example(self, example):
        new_collocation = Example()
        new_collocation.inner = MultiwordExample()
        
        new_collocation.inner.other_attributes["structureName"] = example.structure_name
        new_collocation.inner.other_attributes["logDice"] = example.other["score"]
        new_collocation.inner.other_attributes["frequency"] = example.frequency
        new_collocation.inner.type = "collocation"
        
        lex_left = ComponentLexeme()
        lex_left.text = ""
        lex_left.role = None
        
        lex_mid = ComponentLexeme()
        lex_mid.text = example.word
        lex_mid.role = "headword"
        
        lex_right = ComponentLexeme()
        lex_right.text = ""
        lex_right.role = None
        
        new_collocation.components.extend([lex_left, lex_mid, lex_right])
        return new_collocation