from core.builtin_concepts import BuiltinConcepts
from core.concept import Concept
from core.sheerka.ExecutionContext import ExecutionContext
from sdp.sheerkaDataProvider import SheerkaDataProvider, Event
import pprint
import os


def get_pp():
    rows, columns = os.popen('stty size', 'r').read().split()
    pp = pprint.PrettyPrinter(width=columns, compact=True)
    return pp


class SheerkaDump:
    def __init__(self, sheerka):
        self.sheerka = sheerka

    def dump_concepts(self):
        lst = self.sheerka.sdp.list(self.sheerka.CONCEPTS_ENTRY)
        for item in lst:
            if hasattr(item, "__iter__"):
                for i in item:
                    self.sheerka.log.info(i)
            else:
                self.sheerka.log.info(item)

    def dump_definitions(self):
        defs = self.sheerka.sdp.get(self.sheerka.CONCEPTS_DEFINITIONS_ENTRY)
        self.sheerka.log.info(defs)

    def dump_desc(self, *concept_names, eval=False):
        first = True
        event = Event(f"Dumping description", "")
        context = ExecutionContext("dump_desc", event, self.sheerka)
        for concept_name in concept_names:
            if isinstance(concept_name, Concept):
                concepts = concept_name
            else:
                concepts = self.sheerka.get(concept_name)
                if self.sheerka.isinstance(concepts, BuiltinConcepts.UNKNOWN_CONCEPT):
                    self.sheerka.log.error(f"Concept '{concept_name}' is unknown")
                    return False

            if not hasattr(concepts, "__iter__"):
                concepts = [concepts]

            for c in concepts:
                if eval:
                    evaluated = self.sheerka.evaluate_concept(context, c)
                    value = evaluated.body if evaluated.key == c.key else evaluated

                if not first:
                    self.sheerka.log.info("")
                self.sheerka.log.info(f"name   : {c.name}")
                self.sheerka.log.info(f"bnf    : {c.metadata.definition}")
                self.sheerka.log.info(f"key    : {c.key}")
                self.sheerka.log.info(f"body   : {c.metadata.body}")
                if eval:
                    self.sheerka.log.info(f"value  : {value}")
                for p in c.props:
                    self.sheerka.log.info(f"{p}: {c.get_prop(p)}")
                else:
                    self.sheerka.log.info("No property")

                self.sheerka.log.info(f"digest : {c.get_digest()}")

                if self.sheerka.isaset(context, c):
                    items = self.sheerka.get_set_elements(context, c)
                    self.sheerka.log.info(f"elements  : {items}")

                first = False

    def dump_history(self, page=20, start=0):
        count = 0
        resolved_page = page if page > 0 else 50
        page_count = 0

        while count < page if page > 0 else True:
            history = self.sheerka.history(resolved_page, start + page_count * resolved_page)
            try:
                h = next(history)
            except StopIteration:
                break

            while True:
                try:
                    if h.event.user != self.sheerka.name:
                        self.sheerka.log.info(h)
                        count += 1
                    h = next(history)
                except StopIteration:
                    break

            page_count += 1

    def dump_state(self):
        snapshot = self.sheerka.sdp.get_snapshot(SheerkaDataProvider.HeadFile)
        state = self.sheerka.sdp.load_state(snapshot)
        self.sheerka.log.info(get_pp().pformat(state.data))