import term

from term import Term as T

from dispatch import Dispatcher

import fields

from fields import getter, setter

import updates

from updates import updater

import convert

import properties

import lists

import strings

import builtins

from builtins import builtin

import representations

import utilities

import textwrap

import ints

from ipdb import set_trace as debug

#Making outlines----------------------------------

def node(headline, children):

return T(node.head, headline=headline, children=children)

node.head = "an outline node with headline [headline] and children [children]"

#TODO I want nodes to have children and so on

#which I think can be done by having a translator that pulls "will have children"

#across the toggl expanded update

@builtin("what is the outline, collapsed to its root, that best expresses [quoted_term]?")

def node_from_term(asker, quoted_term):

))

#Outlines to lines--------------------------------

#TODO I should implement caching in a generic way...

cached_lines = fields.atomic_field(

"the function that maps a node to a sequence of lines that represents it"

)

to_lines_Q = "what sequence of lines should represent the outline with root [root]"

@builtin(to_lines_Q)

def outline_to_lines(asker, root):

return asker.reply(answer=result)

is_pointer = properties.atomic_property("the cursor is currently positioned in this node")

#TODO this isn't really an atomic property, the caching infrastructure

#should eventually be good enough that we can be honest about that

#(it can be defined in the normal way, we can cache the result,

#and we can define a translator for the cache to make it so that this all works...)

has_pointer = properties.atomic_property("the cursor is currently positioned in a child of this node")

is_expanded = properties.atomic_property("this node is currently expanded")

@getter("the function that maps a node of an outline "

"to the list of children visible beneath that node")

def visible_children(asker, object):

return asker.reply(answer=children)

@setter(visible_children.head)

def set_visibile_children(asker, object, new_value):

return asker.ask_tail(fields.set_field(all_children(), object, new_value))

all_children = fields.named_binding(

)

#Printing lines-----------------------------------

#FIXME this should probably emit a string or list of strings rather than just print them...

#FIXME this should probably use the conversions machinery

line_printer = Dispatcher("line printer", ("lines", "k", "tab"))

#tab: the string to use for a tab

#k: the number of tabs to use for the outermost line

@builtin("print the lines [lines]")

def print_lines_simple(asker, lines):

return asker.ask_tail(print_lines(lines, T.from_int(0), T.from_str(" ")))

@builtin("print the lines [lines], with a starting indentation of [k], and a tab of [tab]")

def print_lines(asker, lines, k, tab):

line_printer.dispatch(asker, lines, k, tab)

@line_printer("an empty sequence of lines")

def empty_lines(asker, k, tab):

return asker.reply()

@line_printer("the sequence of lines formed by concatenating [a] to [b]")

def concat_lines(asker, k, tab, a, b):

asker.ask(print_lines(a, k, tab))

asker.ask(print_lines(b, k, tab))

return asker.reply()

@line_printer("the sequence of lines formed by indenting [x] once")

def indent_lines(asker, k, tab, x):

asker.ask(print_lines(x, ints.plus_one(k), tab))

return asker.reply()

@line_printer("the sequence of lines consisting of the line whose text is the string [line]")

def one_line(asker, k, tab, line):

print("{}{}".format(initial_tabs if i == 0 else hanging_tabs, wrapped_line))

#Manipulating outlines----------------------------

#Signals and updates--------------------

def moved(d):

return T(moved.head, direction=d)

moved.head = "the user tried to move [direction] out of the movable area"

up = T("the direction up")

down = T("the direction down")

left = T("the direction left")

quit = T("the current interactive exploration should end")

@updater("the update that toggles whether the updated node is expanded")

def toggle_expanded(asker, object):

return asker.reply(answer=result)

@updater("the update that introduces a cursor positioned on the updated node")

def is_pointer_now(asker, object):

result = updates.update(updates.remove_modifier(has_pointer()), object)

result = properties.simple_add_modifier(result, is_pointer())

return asker.reply(answer=result)

@updater("the update that implies that a cursor is positioned beneath the updated node")

def has_pointer_now(asker, object):

return asker.reply(answer=result)

@updater("the update that removes all cursors positioned on or in a descendant of the updated node")

def remove_pointer(asker, object):

return asker.reply(answer=result)

@updater("the update that adds a pointer to the descendant of the updated node "

"which is rendered furthest from node (if the node has no descendants, this updates the node itself)")

def add_pointer_to_bottom(asker, object):

return asker.reply(answer=result)

#Adding children------------------------

children_on_expanded = term.simple("when expanded, should be given children from [bindings]", "bindings")

@updates.translator(children_on_expanded.head, toggle_expanded.head)

def add_children_on_expanded(asker, old, new, bindings):

))

updates.translate_simply(children_on_expanded.head, exclude=[toggle_expanded.head])

headline = fields.named_binding(

)

#Processing input-----------------------

process_char_Q = ("what should [root] transform into if the user types [c] while exploring it, "

"given that it has parents [parents]?")

@builtin(process_char_Q)

def process_char(asker, root, c, parents):

return asker.reply()

@builtin("the user wants to interact with the outline [root], in the context of parents [parents]")

def explore_node(asker, root, parents):

asker.ask(process_char(root, T.from_char(c), parents))