From 8822ee7e3069193162469438bb54ee4629e1ae19 Mon Sep 17 00:00:00 2001
From: Christian Heller <c.heller@plomlompom.de>
Date: Mon, 8 Jan 2024 08:18:30 +0100
Subject: [PATCH] Improve accounting scripts.

---
 ledger.py                    | 1780 +++++++++++++++++++++-------------
 todo.py                      |   49 +-
 todo_templates/calendar.html |    2 +-
 todo_templates/day.html      |   19 +-
 todo_templates/tasks.html    |    2 +-
 5 files changed, 1181 insertions(+), 671 deletions(-)

diff --git a/ledger.py b/ledger.py
index 0ef3d44..aa295d2 100755
--- a/ledger.py
+++ b/ledger.py
@@ -1,410 +1,779 @@
 import os
-import jinja2
 import decimal
 from datetime import datetime, timedelta
 from urllib.parse import parse_qs, urlparse
+from jinja2 import Environment as JinjaEnv, FileSystemLoader as JinjaFSLoader 
 from plomlib import PlomDB, PlomException, run_server, PlomHandler 
 
-server_port = 8082
 db_path = '/home/plom/org/ledger2024.dat'
+server_port = 8082
+j2env = JinjaEnv(loader=JinjaFSLoader('ledger_templates'))
 
-html_head = """
-<style>
-body { color: #000000; }
-table { margin-bottom: 2em; }
-th, td { text-align: left }
-input[type=number] { text-align: right; font-family: monospace; }
-.money { font-family: monospace; text-align: right; }
-.comment { font-style: italic; color: #777777; }
-.meta { font-size: 0.75em; color: #777777; }
-.full_line_comment { display: block; white-space: nowrap; width: 0; }
-</style>
-<body>
-<a href="{{prefix}}/ledger">ledger</a>
-<a href="{{prefix}}/balance">balance</a>
-<a href="{{prefix}}/add_free">add free</a>
-<a href="{{prefix}}/add_structured">add structured</a>
-<hr />
-"""
-booking_html = """
-<p id="{{nth}}"><a href="{{prefix}}#{{nth}}">{{date}}</a> {{desc}} <span class="comment">{{head_comment|e}}</span><br />
-<span class="meta">[edit: <a href="{{prefix}}/add_structured?start={{start}}&end={{end}}">structured</a>
-/ <a href="{{prefix}}/add_free?start={{start}}&end={{end}}">free</a>
-| copy:<a href="{{prefix}}/copy_structured?start={{start}}&end={{end}}">structured</a>
-/ <a href="{{prefix}}/copy_free?start={{start}}&end={{end}}">free</a>
-| move {% if move_up %}<a href="{{prefix}}/move_up?start={{start}}&end={{end}}">up</a>{% else %}up{% endif %}/{% if move_down %}<a href="{{prefix}}/move_down?start={{start}}&end={{end}}">down</a>{% else %}down{% endif %}
-| <a href="{{prefix}}/balance?stop={{nth+1}}">balance after</a>
-]</span>
-<table>
-{% for l in booking_lines %}
-{% if l.acc %}
-<tr><td>{{l.acc|e}}</td><td class="money">{{l.money|e}}</td><td class="comment">{{l.comment|e}}</td></tr>
-{% else %}
-<tr><td><div class="comment full_line_comment">{{l.comment|e}}</div></td></tr>
-{% endif %}
-{% endfor %}
-</table></p>
-"""
-add_form_header = """<form method="POST" action="{{action|e}}">
-<input type="submit" name="check" value="check" tabindex="5"  />
-<input type="submit" name="revert" value="revert" tabindex="5"  />
-"""
-add_form_footer = """
-<input type="hidden" name="start" value={{start}} />
-<input type="hidden" name="end" value={{end}} />
-<input type="submit" name="save" value="save!" tabindex="5" >
-</form>
-"""
-add_free_html = """<br />
-<textarea name="booking" rows=10 cols=80>{% for line in lines %}{{ line }}{% if not loop.last %}
-{% endif %}{% endfor %}</textarea>
-"""
-add_structured_html = """
-<input type="submit" name="add_taxes" value="add taxes" tabindex="5" />
-<input type="submit" name="add_taxes2" value="add taxes2" tabindex="5"  />
-<input type="submit" name="add_sink" value="add sink" tabindex="5"  />
-<input name="replace_from" tabindex="5"  />
-<input type="submit" name="replace" value="-> replace ->" tabindex="5"  />
-<input name="replace_to" tabindex="5"  />
-<input type="submit" name="add_mirror" value="add mirror" tabindex="5"  />
-<br />
-<input name="date" value="{{date|e}}" size=9 tabindex="3"  />
-<input name="description" value="{{desc|e}}" list="descriptions" tabindex="3"  />
-<textarea name="line_0_comment" rows=1 cols=20 tabindex="3" >{{head_comment|e}}</textarea>
-<input type="submit" name="line_0_add" value="[+]" tabindex="5"  />
-<br />
-{% for line in booking_lines %}
-<input name="line_{{line.i}}_account" value="{{line.acc|e}}" size=40 list="accounts" tabindex="3" />
-<input type="number" name="line_{{line.i}}_amount" step=0.01 value="{{line.amt}}" size=10 tabindex="3" />
-<input name="line_{{line.i}}_currency" value="{{line.curr|e}}" size=3 list="currencies" tabindex="5" />
-<input type="submit" name="line_{{line.i}}_delete" value="[x]" tabindex="5" />
-<input type="submit" name="line_{{line.i}}_delete_after" value="[XX]" tabindex="5" />
-<input type="submit" name="line_{{line.i}}_add" value="[+]" tabindex="5" />
-<textarea name="line_{{line.i}}_comment" rows=1 cols={% if line.comm_cols %}{{line.comm_cols}}{% else %}20{% endif %} tabindex="3">{{line.comment|e}}</textarea>
-<br />
-{% endfor %}
-{% for name, items in datalist_sets.items() %}
-<datalist id="{{name}}">
-{% for item in items %}
-  <option value="{{item|e}}">{{item|e}}</option>
-{% endfor %}
-</datalist>
-{% endfor %}
-"""
-
-
-def apply_booking_to_account_balances(account_sums, account, currency, amount):
-    if not account in account_sums:
-        account_sums[account] = {currency: amount}
-    elif not currency in account_sums[account].keys():
-        account_sums[account][currency] = amount
-    else:
-        account_sums[account][currency] += amount
-
-
-def bookings_to_account_tree(bookings):
-    account_sums = {}
-    for booking in bookings:
-        for account, changes in booking.account_changes.items():
-            for currency, amount in changes.items():
-                apply_booking_to_account_balances(account_sums, account, currency, amount)
-    account_tree = {}
-    def collect_branches(account_name, path):
-        node = account_tree
-        path_copy = path[:]
-        while len(path_copy) > 0:
-            step = path_copy.pop(0)
-            node = node[step]
-        toks = account_name.split(":", maxsplit=1)
-        parent = toks[0]
-        if parent in node.keys():
-            child = node[parent]
-        else:
-            child = {}
-            node[parent] = child
-        if len(toks) == 2:
-            k, v = collect_branches(toks[1], path + [parent])
-            if k not in child.keys():
-                child[k] = v
-            else:
-                child[k].update(v)
-        return parent, child
-    for account_name in sorted(account_sums.keys()):
-        k, v = collect_branches(account_name, [])
-        if k not in account_tree.keys():
-            account_tree[k] = v
+class EditableException(PlomException):
+    def __init__(self, booking_index, *args, **kwargs):
+        self.booking_index = booking_index
+        super().__init__(*args, **kwargs)
+    
+
+# html_head = """
+# <style>
+# body { color: #000000; }
+# table { margin-bottom: 2em; }
+# th, td { text-align: left }
+# input[type=number] { text-align: right; font-family: monospace; }
+# .money { font-family: monospace; text-align: right; }
+# .comment { font-style: italic; color: #777777; }
+# .meta { font-size: 0.75em; color: #777777; }
+# .full_line_comment { display: block; white-space: nowrap; width: 0; }
+# </style>
+# <body>
+# <a href="{{prefix}}/ledger">ledger</a>
+# <a href="{{prefix}}/ledger2">ledger2</a>
+# <a href="{{prefix}}/balance">balance</a>
+# <a href="{{prefix}}/balance2">balance2</a>
+# <a href="{{prefix}}/add_free">add free</a>
+# <a href="{{prefix}}/add_structured">add structured</a>
+# <a href="{{prefix}}/edit">add</a>
+# <hr />
+# """
+# booking_html = """
+# <p id="{{nth}}"><a href="{{prefix}}#{{nth}}">{{date}}</a> {{desc}} <span class="comment">{{head_comment|e}}</span><br />
+# <span class="meta">[edit: <a href="{{prefix}}/add_structured?start={{start}}&end={{end}}">structured</a>
+# / <a href="{{prefix}}/add_free?start={{start}}&end={{end}}">free</a>
+# | copy:<a href="{{prefix}}/copy_structured?start={{start}}&end={{end}}">structured</a>
+# / <a href="{{prefix}}/copy_free?start={{start}}&end={{end}}">free</a>
+# | move {% if move_up %}<a href="{{prefix}}/move_up?start={{start}}&end={{end}}">up</a>{% else %}up{% endif %}/{% if move_down %}<a href="{{prefix}}/move_down?start={{start}}&end={{end}}">down</a>{% else %}down{% endif %}
+# | <a href="{{prefix}}/balance?stop={{nth+1}}">balance after</a>
+# ]</span>
+# <table>
+# {% for l in booking_lines %}
+# {% if l.acc %}
+# <tr><td>{{l.acc|e}}</td><td class="money">{{l.money|e}}</td><td class="comment">{{l.comment|e}}</td></tr>
+# {% else %}
+# <tr><td><div class="comment full_line_comment">{{l.comment|e}}</div></td></tr>
+# {% endif %}
+# {% endfor %}
+# </table></p>
+# """
+# add_form_header = """<form method="POST" action="{{action|e}}">
+# <input type="submit" name="check" value="check" tabindex="5"  />
+# <input type="submit" name="revert" value="revert" tabindex="5"  />
+# """
+# add_form_footer = """
+# <input type="hidden" name="start" value={{start}} />
+# <input type="hidden" name="end" value={{end}} />
+# <input type="submit" name="save" value="save!" tabindex="5" >
+# </form>
+# """
+# add_free_html = """<br />
+# <textarea name="booking" rows=10 cols=80>{% for line in lines %}{{ line }}{% if not loop.last %}
+# {% endif %}{% endfor %}</textarea>
+# """
+# add_structured_html = """
+# <input type="submit" name="add_taxes" value="add taxes" tabindex="5" />
+# <input type="submit" name="add_taxes2" value="add taxes2" tabindex="5"  />
+# <input type="submit" name="add_sink" value="add sink" tabindex="5"  />
+# <input name="replace_from" tabindex="5"  />
+# <input type="submit" name="replace" value="-> replace ->" tabindex="5"  />
+# <input name="replace_to" tabindex="5"  />
+# <input type="submit" name="add_mirror" value="add mirror" tabindex="5"  />
+# <br />
+# <input name="date" value="{{date|e}}" size=9 tabindex="3"  />
+# <input name="description" value="{{desc|e}}" list="descriptions" tabindex="3"  />
+# <textarea name="line_0_comment" rows=1 cols=20 tabindex="3" >{{head_comment|e}}</textarea>
+# <input type="submit" name="line_0_add" value="[+]" tabindex="5"  />
+# <br />
+# {% for line in booking_lines %}
+# <input name="line_{{line.i}}_account" value="{{line.acc|e}}" size=40 list="accounts" tabindex="3" />
+# <input type="number" name="line_{{line.i}}_amount" step=0.01 value="{{line.amt}}" size=10 tabindex="3" />
+# <input name="line_{{line.i}}_currency" value="{{line.curr|e}}" size=3 list="currencies" tabindex="5" />
+# <input type="submit" name="line_{{line.i}}_delete" value="[x]" tabindex="5" />
+# <input type="submit" name="line_{{line.i}}_delete_after" value="[XX]" tabindex="5" />
+# <input type="submit" name="line_{{line.i}}_add" value="[+]" tabindex="5" />
+# <textarea name="line_{{line.i}}_comment" rows=1 cols={% if line.comm_cols %}{{line.comm_cols}}{% else %}20{% endif %} tabindex="3">{{line.comment|e}}</textarea>
+# <br />
+# {% endfor %}
+# {% for name, items in datalist_sets.items() %}
+# <datalist id="{{name}}">
+# {% for item in items %}
+#   <option value="{{item|e}}">{{item|e}}</option>
+# {% endfor %}
+# </datalist>
+# {% endfor %}
+# """
+
+
+class Wealth:
+
+    def __init__(self):
+        self.money_dict = {}
+
+    def add_money_dict(self, moneys):
+        for currency, amount in moneys.items():
+            if not currency in self.money_dict.keys():
+                self.money_dict[currency] = 0
+            self.money_dict[currency] += amount
+
+    def add_wealth(self, moneys):
+        self.add_money_dict(moneys.money_dict)
+
+    @property
+    def as_sink_dict(self):
+        sink = {} 
+        for currency, amount in self.money_dict.items():
+            if 0 == amount:
+                continue
+            sink[currency] = -amount
+        return sink 
+
+
+class Account:
+
+    def __init__(self, own_name, parent):
+        self.own_name = own_name
+        self.parent = parent
+        if self.parent:
+            self.parent.children += [self]
+        self.own_moneys = Wealth() 
+        self.children = []
+
+    def add_wealth(self, moneys):
+        self.own_moneys.add_wealth(moneys)
+
+    @property
+    def full_name(self):
+        if self.parent and len(self.parent.own_name) > 0:
+            return f'{self.parent.full_name}:{self.own_name}'
         else:
-            account_tree[k].update(v)
-    def collect_totals(parent_path, tree_node):
-        for k, v in tree_node.items():
-            child_path = parent_path + ":" + k
-            for currency, amount in collect_totals(child_path, v).items():
-                apply_booking_to_account_balances(account_sums, parent_path, currency, amount)
-        return account_sums[parent_path]
-    for account_name in account_tree.keys():
-        account_sums[account_name] = collect_totals(account_name, account_tree[account_name])
-    return account_tree, account_sums
-
-
-def parse_lines(lines, validate_bookings=True):
+            return self.own_name
+
+    @property
+    def full_moneys(self):
+        full_moneys = Wealth() 
+        full_moneys.add_wealth(self.own_moneys)
+        for child in self.children:
+            full_moneys.add_wealth(child.full_moneys)
+        return full_moneys
+
+
+# def apply_booking_to_account_balances(account_sums, account, currency, amount):
+#     if not account in account_sums:
+#         account_sums[account] = {currency: amount}
+#     elif not currency in account_sums[account].keys():
+#         account_sums[account][currency] = amount
+#     else:
+#         account_sums[account][currency] += amount
+# 
+# 
+# def bookings_to_account_tree(bookings):
+#     account_sums = {}
+#     for booking in bookings:
+#         for account, changes in booking.account_changes.items():
+#             for currency, amount in changes.items():
+#                 apply_booking_to_account_balances(account_sums, account, currency, amount)
+#     account_tree = {}
+#     def collect_branches(account_name, path):
+#         node = account_tree
+#         path_copy = path[:]
+#         while len(path_copy) > 0:
+#             step = path_copy.pop(0)
+#             node = node[step]
+#         toks = account_name.split(":", maxsplit=1)
+#         parent = toks[0]
+#         if parent in node.keys():
+#             child = node[parent]
+#         else:
+#             child = {}
+#             node[parent] = child
+#         if len(toks) == 2:
+#             k, v = collect_branches(toks[1], path + [parent])
+#             if k not in child.keys():
+#                 child[k] = v
+#             else:
+#                 child[k].update(v)
+#         return parent, child
+#     for account_name in sorted(account_sums.keys()):
+#         k, v = collect_branches(account_name, [])
+#         if k not in account_tree.keys():
+#             account_tree[k] = v
+#         else:
+#             account_tree[k].update(v)
+#     def collect_totals(parent_path, tree_node):
+#         for k, v in tree_node.items():
+#             child_path = parent_path + ":" + k
+#             for currency, amount in collect_totals(child_path, v).items():
+#                 apply_booking_to_account_balances(account_sums, parent_path, currency, amount)
+#         return account_sums[parent_path]
+#     for account_name in account_tree.keys():
+#         account_sums[account_name] = collect_totals(account_name, account_tree[account_name])
+#     return account_tree, account_sums
+
+
+def parse_lines2(lines, ignore_editable_exceptions=False):
+    lines = lines.copy() + ['']  # to simulate ending of last booking
+    bookings = []
     inside_booking = False
-    date_string, description = None, None
     booking_lines = []
-    start_line = 0
-    bookings = []
-    comments = []
-    lines = lines.copy() + [''] # to ensure a booking-ending last line
-    last_date = ''
+    booking_start_i = 0
+    last_date = '' 
     for i, line in enumerate(lines):
-        prefix = f"line {i}"
-        # we start with the case of an utterly empty line
-        comments += [""]
+        intro = f'file line {i}'
         stripped_line = line.rstrip()
         if stripped_line == '':
             if inside_booking:
-                # assume we finished a booking, finalize, and commit to DB
-                if len(booking_lines) < 2:
-                    raise PlomException(f"{prefix} booking ends to early")
-                booking = Booking(date_string, description, booking_lines, start_line, validate_bookings)
+                booking = Booking(lines=booking_lines, starts_at=booking_start_i)
+                if last_date > booking.date and not ignore_editable_exceptions:
+                    raise EditableException(len(bookings), f'{intro}: out-of-order date (follows {last_date})')
+                last_date = booking.date
                 bookings += [booking]
-            # expect new booking to follow so re-zeroall booking data
-            inside_booking = False
-            date_string, description = None, None
-            booking_lines = []
-            continue
-        # if non-empty line, first get comment if any, and commit to DB
-        split_by_comment = stripped_line.split(sep=";", maxsplit=1)
-        if len(split_by_comment) == 2:
-            comments[i] = split_by_comment[1].lstrip()
-        # if pre-comment empty: if inside_booking, this must be a comment-only line so we keep it for later ledger-output to capture those comments; otherwise, no more to process for this line
-        non_comment = split_by_comment[0].rstrip()
-        if non_comment.rstrip() == '':
-             if inside_booking:
-                 booking_lines += ['']
-             continue
-        # if we're starting a booking, parse by first-line pattern
-        if not inside_booking:
-            start_line = i
-            toks = non_comment.split(maxsplit=1)
-            date_string = toks[0]
-            try:
-                datetime.strptime(date_string, '%Y-%m-%d')
-            except ValueError:
-                raise PlomException(f"{prefix} bad date string: {date_string}")
-            if last_date > date_string:
-                raise PlomException(f"{prefix} out-of-order-date")
-            last_date = date_string
-            try:
-                description = toks[1]
-            except IndexError:
-                raise PlomException(f"{prefix} bad description: {description}")
+                inside_booking =False
+                booking_lines = []
+        else:
+            if not inside_booking:
+                booking_start_i = i
             inside_booking = True
-            booking_lines += [non_comment]
-            continue
-        # otherwise, read as transfer data
-        toks = non_comment.split()  # ignore specification's allowance of single spaces in names
-        if len(toks) > 3:
-            raise PlomException(f"{prefix} too many booking line tokens: {toks}")
-        amount, currency = None, None
-        account_name = toks[0]
-        if account_name[0] == '[' and account_name[-1] == ']':
-            # ignore specification's differentiation of "virtual" accounts
-            account_name = account_name[1:-1]
-        decimal_chars = ".-0123456789"
-        if len(toks) == 3:
-            i_currency = 1
-            try:
-                amount = decimal.Decimal(toks[1])
-                i_currency = 2
-            except decimal.InvalidOperation:
+            booking_lines += [line]
+    if inside_booking:
+        raise PlomException(f'{intro}: last booking unfinished')
+    return bookings
+
+
+# def parse_lines(lines, validate_bookings=True):
+#     inside_booking = False
+#     date_string, description = None, None
+#     booking_lines = []
+#     start_line = 0
+#     bookings = []
+#     comments = []
+#     lines = lines.copy() + [''] # to ensure a booking-ending last line
+#     last_date = ''
+#     for i, line in enumerate(lines):
+#         prefix = f"line {i}"
+#         # we start with the case of an utterly empty line
+#         comments += [""]
+#         stripped_line = line.rstrip()
+#         if stripped_line == '':
+#             if inside_booking:
+#                 # assume we finished a booking, finalize, and commit to DB
+#                 if len(booking_lines) < 2:
+#                     raise PlomException(f"{prefix} booking ends to early")
+#                 booking = Booking(date_string, description, booking_lines, start_line, validate_bookings)
+#                 bookings += [booking]
+#             # expect new booking to follow so re-zeroall booking data
+#             inside_booking = False
+#             date_string, description = None, None
+#             booking_lines = []
+#             continue
+#         # if non-empty line, first get comment if any, and commit to DB
+#         split_by_comment = stripped_line.split(sep=";", maxsplit=1)
+#         if len(split_by_comment) == 2:
+#             comments[i] = split_by_comment[1].lstrip()
+#         # if pre-comment empty: if inside_booking, this must be a comment-only line so we keep it for later ledger-output to capture those comments; otherwise, no more to process for this line
+#         non_comment = split_by_comment[0].rstrip()
+#         if non_comment.rstrip() == '':
+#              if inside_booking:
+#                  booking_lines += ['']
+#              continue
+#         # if we're starting a booking, parse by first-line pattern
+#         if not inside_booking:
+#             start_line = i
+#             toks = non_comment.split(maxsplit=1)
+#             date_string = toks[0]
+#             try:
+#                 datetime.strptime(date_string, '%Y-%m-%d')
+#             except ValueError:
+#                 raise PlomException(f"{prefix} bad date string: {date_string}")
+#             # if last_date > date_string:
+#             #     raise PlomException(f"{prefix} out-of-order-date")
+#             last_date = date_string
+#             try:
+#                 description = toks[1]
+#             except IndexError:
+#                 raise PlomException(f"{prefix} bad description: {description}")
+#             inside_booking = True
+#             booking_lines += [non_comment]
+#             continue
+#         # otherwise, read as transfer data
+#         toks = non_comment.split()  # ignore specification's allowance of single spaces in names
+#         if len(toks) > 3:
+#             raise PlomException(f"{prefix} too many booking line tokens: {toks}")
+#         amount, currency = None, None
+#         account_name = toks[0]
+#         if account_name[0] == '[' and account_name[-1] == ']':
+#             # ignore specification's differentiation of "virtual" accounts
+#             account_name = account_name[1:-1]
+#         decimal_chars = ".-0123456789"
+#         if len(toks) == 3:
+#             i_currency = 1
+#             try:
+#                 amount = decimal.Decimal(toks[1])
+#                 i_currency = 2
+#             except decimal.InvalidOperation:
+#                 try:
+#                     amount = decimal.Decimal(toks[2])
+#                 except decimal.InvalidOperation:
+#                     raise PlomException(f"{prefix} no decimal number in: {toks[1:]}")
+#             currency = toks[i_currency]
+#             if currency[0] in decimal_chars:
+#                 raise PlomException(f"{prefix} currency starts with int, dot, or minus: {currency}")
+#         elif len(toks) == 2:
+#             value = toks[1]
+#             inside_amount = False
+#             inside_currency = False
+#             amount_string = ""
+#             currency = ""
+#             dots_counted = 0
+#             for i, c in enumerate(value):
+#                 if i == 0:
+#                     if c in decimal_chars:
+#                         inside_amount = True
+#                     else:
+#                         inside_currency = True
+#                 if inside_currency:
+#                     if c in decimal_chars and len(amount_string) == 0:
+#                         inside_currency = False
+#                         inside_amount = True
+#                     else:
+#                         currency += c
+#                         continue
+#                 if inside_amount:
+#                     if c not in decimal_chars:
+#                         if len(currency) > 0:
+#                             raise PlomException(f"{prefix} amount has non-decimal chars: {value}")
+#                         inside_currency = True
+#                         inside_amount = False
+#                         currency += c
+#                         continue
+#                     if c == '-' and len(amount_string) > 1:
+#                         raise PlomException(f"{prefix} amount has non-start '-': {value}")
+#                     if c == '.':
+#                         if dots_counted > 1:
+#                             raise PlomException(f"{prefix} amount has multiple dots: {value}")
+#                         dots_counted += 1
+#                     amount_string += c
+#             if len(currency) == 0:
+#                 raise PlomException(f"{prefix} currency missing: {value}")
+#             if len(amount_string) > 0:
+#                 amount = decimal.Decimal(amount_string)
+#         booking_lines += [(account_name, amount, currency)]
+#     if inside_booking:
+#         raise PlomException(f"{prefix} last booking unfinished")
+#     return bookings, comments
+
+
+class TransferLine:
+
+    def __init__(self, line=None, account='', amount=None, currency='', comment='', validate=True):
+        self.account = account 
+        self.amount = amount 
+        self.currency = currency 
+        self.comment = comment 
+        if line:
+            split_by_comment = line.rstrip().split(sep=';', maxsplit=1)
+            if len(split_by_comment) == 0:
+                raise PlomException('line empty')
+            elif len(split_by_comment) == 2:
+                self.comment = split_by_comment[1].lstrip()
+            non_comment = split_by_comment[0].rstrip()
+            toks = non_comment.split()
+            if (len(toks) not in {1, 3}):
+                if validate:
+                    raise PlomException(f'number of non-comment tokens not 1 or 3')
+                elif len(toks) == 2:
+                    toks += ['']
+                else:
+                    toks = 3*['']
+            self.account = toks[0]
+            if len(toks) != 1:
                 try:
-                    amount = decimal.Decimal(toks[2])
+                    self.amount = decimal.Decimal(toks[1])
                 except decimal.InvalidOperation:
-                    raise PlomException(f"{prefix} no decimal number in: {toks[1:]}")
-            currency = toks[i_currency]
-            if currency[0] in decimal_chars:
-                raise PlomException(f"{prefix} currency starts with int, dot, or minus: {currency}")
-        elif len(toks) == 2:
-            value = toks[1]
-            inside_amount = False
-            inside_currency = False
-            amount_string = ""
-            currency = ""
-            dots_counted = 0
-            for i, c in enumerate(value):
-                if i == 0:
-                    if c in decimal_chars:
-                        inside_amount = True
+                    if validate:
+                        raise PlomException(f'invalid token for Decimal: {toks[1]}')
                     else:
-                        inside_currency = True
-                if inside_currency:
-                    if c in decimal_chars and len(amount_string) == 0:
-                        inside_currency = False
-                        inside_amount = True
-                    else:
-                        currency += c
-                        continue
-                if inside_amount:
-                    if c not in decimal_chars:
-                        if len(currency) > 0:
-                            raise PlomException(f"{prefix} amount has non-decimal chars: {value}")
-                        inside_currency = True
-                        inside_amount = False
-                        currency += c
-                        continue
-                    if c == '-' and len(amount_string) > 1:
-                        raise PlomException(f"{prefix} amount has non-start '-': {value}")
-                    if c == '.':
-                        if dots_counted > 1:
-                            raise PlomException(f"{prefix} amount has multiple dots: {value}")
-                        dots_counted += 1
-                    amount_string += c
-            if len(currency) == 0:
-                raise PlomException(f"{prefix} currency missing: {value}")
-            if len(amount_string) > 0:
-                amount = decimal.Decimal(amount_string)
-        booking_lines += [(account_name, amount, currency)]
-    if inside_booking:
-        raise PlomException(f"{prefix} last booking unfinished")
-    return bookings, comments
+                        self.amount = toks[1]
+                self.currency = toks[2]
+
+    @property
+    def amount_fmt(self):
+        if self.amount is None:
+            return ''
+        elif self.amount.as_tuple().exponent < -2:
+            return f'{self.amount:.1f}…'
+        else:
+            return f'{self.amount:.2f}'
+
+    def for_writing(self):
+        line = f'  {self.account}'
+        if self.amount is not None:
+            line += f'  {self.amount} {self.currency}'
+        if self.comment != '':
+            line += f' ; {self.comment}' 
+        return line
+
+    @property
+    def comment_cols(self):
+        return max(20, len(self.comment))
 
 
 class Booking:
 
-    def __init__(self, date_string, description, booking_lines, start_line, process=True):
-        self.date_string = date_string
-        self.description = description
-        self.lines = booking_lines
-        self.start_line = start_line
-        if process:
-            self.validate_booking_lines()
-            self.sink = {}
-            self.account_changes = self.parse_booking_lines_to_account_changes()
-
-    def validate_booking_lines(self):
-        prefix = f"booking at line {self.start_line}"
-        sums = {}
-        empty_values = 0
-        for line in self.lines[1:]:
-            if line == '':
-                continue
-            _, amount, currency = line
-            if amount is None:
-                if empty_values > 0:
-                    raise PlomException(f"{prefix} relates more than one empty value of same currency {currency}")
-                empty_values += 1
-                continue
-            if currency not in sums:
-                sums[currency] = 0
-            sums[currency] += amount
-        if empty_values == 0:
-            for k, v in sums.items():
-                if v != 0:
-                    raise PlomException(f"{prefix} does not add up to zero / {k} {v}")
+    def __init__(self, lines=None, starts_at='?', date='', description='', top_comment='', transfer_lines=None, validate=True):
+        self.validate = validate
+        self.starts_at = starts_at 
+        self.intro = f'booking starting at line {self.starts_at}'
+        self.clean()
+        if lines:
+            self.real_lines = lines 
+            self.parse_lines()
         else:
-            sinkable = False
-            for k, v in sums.items():
-                if v != 0:
-                    sinkable = True
-            if not sinkable:
-                raise PlomException(f"{prefix} has empty value that cannot be filled")
-
-    def parse_booking_lines_to_account_changes(self):
-        account_changes = {}
-        debt = {}
-        sink_account = None
-        for line in self.lines[1:]:
-            if line == '':
-                continue
-            account, amount, currency = line
-            if amount is None:
-                sink_account = account
+            self.date = date
+            self.description = description
+            self.top_comment = top_comment 
+            self.validate_head()
+            self.transfer_lines = transfer_lines
+            if len(self.transfer_lines) < 2 and self.validate:
+                raise PlomException(f'{self.intro}: too few transfer lines')
+            self.calculate_account_changes()
+            self.real_lines = self.for_writing()
+
+    @classmethod
+    def from_postvars(cls, postvars, starts_at='?', validate=True):
+        date = postvars['date'][0] 
+        description = postvars['description'][0] 
+        top_comment = postvars['top_comment'][0] 
+        transfer_lines = []
+        for i, account in enumerate(postvars['account']):
+            if len(account) == 0:
                 continue
-            apply_booking_to_account_balances(account_changes, account, currency, amount)
-            if currency not in debt:
-                debt[currency] = amount
+            amount = None
+            if len(postvars['amount'][i]) > 0:
+                amount = decimal.Decimal(postvars['amount'][i])
+            transfer_lines += [TransferLine(None, account, amount, postvars['currency'][i], postvars['comment'][i])]
+        return cls(None, starts_at, date, description, top_comment, transfer_lines, validate=validate)
+
+    def clean(self):
+        self.transfer_lines = []
+        self.account_changes = {}
+
+    def parse_lines(self):
+        self.top_comment = '' 
+        if len(self.real_lines) < 3 and self.validate:
+            raise PlomException(f'{self.intro}: ends with less than 3 lines:' + str(self.real_lines))
+        split_by_comment = self.real_lines[0].rstrip().split(sep=";", maxsplit=1)
+        if len(split_by_comment) == 0 and self.validate:
+            raise PlomException('{self.intro}: headline empty')
+        elif len(split_by_comment) == 2 and self.validate:
+            self.top_comment = split_by_comment[1].lstrip()
+        non_comment = split_by_comment[0].rstrip()
+        toks = non_comment.split()
+        if len(toks) < 2:
+            if self.validate:
+                raise PlomException(f'{self.intro}: headline missing elements: {non_comment}')
+            elif 0 == len(toks):
+                toks = 2*['']
+            else:
+                toks += ['']
+        self.date = toks[0]
+        self.description = toks[1]
+        self.validate_head()
+        for i, line in enumerate(self.real_lines[1:]):
+            try:
+                self.transfer_lines += [TransferLine(line, validate=self.validate)]
+            except PlomException as e:
+                raise PlomException(f'{self.intro}, transfer line {i}: {e}')
+        self.calculate_account_changes()
+
+    def calculate_account_changes(self):
+        sink_account = None 
+        money_changes = Wealth() 
+        for i, transfer_line in enumerate(self.transfer_lines):
+            intro = f'{self.intro}, transfer line {i}'
+            if transfer_line.amount is None:
+                if sink_account is not None and self.validate:
+                    raise PlomException(f'{intro}: second sink found (only one allowed)')
+                sink_account = transfer_line.account
+            else:
+                if not transfer_line.account in self.account_changes.keys():
+                    self.account_changes[transfer_line.account] = Wealth()
+                money = {transfer_line.currency: transfer_line.amount}
+                self.account_changes[transfer_line.account].add_money_dict(money)
+                money_changes.add_money_dict(money)
+        if sink_account is None and len(money_changes.as_sink_dict) > 0 and self.validate:
+            raise PlomException(f'{intro}: does not balance (unused non-empty sink)')
+        if sink_account is not None:
+            if not sink_account in self.account_changes.keys():
+                self.account_changes[sink_account] = Wealth()
+            self.account_changes[sink_account].add_money_dict(money_changes.as_sink_dict)
+
+    def validate_head(self):
+        if not self.validate:
+            return
+        if len(self.date) == 0:
+            raise PlomException(f'{self.intro}: missing date')
+        if len(self.description) == 0:
+            raise PlomException(f'{self.intro}: missing description')
+        try:
+            datetime.strptime(self.date, '%Y-%m-%d')
+        except ValueError:
+            raise PlomException(f'{self.intro}: bad headline date format: {self.date}')
+
+    def fill_sink(self):
+        replacement_lines = []
+        for i, line in enumerate(self.transfer_lines):
+            if line.amount is None:
+                for currency, amount in self.account_changes[line.account].money_dict.items():
+                    replacement_lines += [TransferLine(None, f'{line.account}', amount, currency).for_writing()]
+                break
+        lines = self.real_lines[:i+1] + replacement_lines + self.real_lines[i+2:]
+        self.clean()
+        self.real_lines = lines
+        self.parse_lines()
+
+    def add_mirror(self):
+        new_transfer_lines = []
+        for line in self.transfer_lines:
+            new_transfer_lines += [TransferLine(None, f'({line.account})', line.amount, line.currency, line.comment)]
+        for transfer_line in new_transfer_lines:
+            self.real_lines += [transfer_line.for_writing()]
+        self.clean()
+        self.parse_lines()
+
+    def add_taxes(self):
+        acc_kk_add = 'Reserves:KrankenkassenBeitragsWachstum'
+        acc_kk_minimum = 'Reserves:Month:KrankenkassenDefaultBeitrag'
+        acc_kk = 'Expenses:KrankenKasse'
+        acc_est = 'Reserves:EinkommensSteuer'
+        acc_assets = 'Assets'
+        acc_buffer = 'Reserves:NeuAnfangsPuffer:Ausgaben'
+        buffer_expenses = 0  # FIXME: hardcoded for now 
+        kk_expenses = 0  # FIXME: hardcoded for now 
+        est_expenses = 0  # FIXME: hardcoded for now 
+        months_passed = 0  # FIXME: hardcoded for now 
+        last_monthbreak_assets = 0  # FIXME: hardcoded for now 
+        last_monthbreak_est = 0  # FIXME: hardcoded for now 
+        last_monthbreak_kk_minimum = 0  # FIXME: hardcoded for now 
+        last_monthbreak_kk_add = 0  # FIXME: hardcoded for now 
+        expenses_so_far = 0  # FIXME: hardcoded for now 
+        needed_netto = self.account_changes['Assets'].money_dict['€']
+        ESt_this_month = 0
+        left_over = needed_netto - ESt_this_month
+        too_low = 0
+        too_high = 2 * needed_netto 
+        E0 = decimal.Decimal(10908)
+        E1 = decimal.Decimal(15999)
+        E2 = decimal.Decimal(62809)
+        E3 = decimal.Decimal(277825)
+        while True:
+            zvE = buffer_expenses - kk_expenses + (12 - months_passed) * needed_netto 
+            # if finish:
+            #     zvE += last_monthbreak_assets + last_monthbreak_kk_add + last_monthbreak_kk_minimum
+            if zvE < E0:
+                ESt = decimal.Decimal(0)
+            elif zvE < E1:
+                y = (zvE - E0)/10000
+                ESt = (decimal.Decimal(979.18) * y + 1400) * y
+            elif zvE < E2:
+                y = (zvE - E1)/10000
+                ESt = (decimal.Decimal(192.59) * y + 2397) * y + decimal.Decimal(966.53)
+            elif zvE < E3:
+                ESt = decimal.Decimal(0.42) * (zvE - decimal.Decimal(62809))  + decimal.Decimal(16405.54)
             else:
-                debt[currency] += amount
-        if sink_account:
-            for currency, amount in debt.items():
-                apply_booking_to_account_balances(account_changes, sink_account, currency, -amount)
-                self.sink[currency] = -amount
-        return account_changes
+                ESt = decimal.Decimal(0.45) * (zvE - decimal.Decimal(277825)) + decimal.Decimal(106713.52)
+            ESt_this_month = (ESt + last_monthbreak_est - est_expenses) / (12 - months_passed)
+            left_over = needed_netto - ESt_this_month
+            if abs(left_over - expenses_so_far) < 0.001:
+                break
+            elif left_over < expenses_so_far:
+                too_low = needed_netto 
+            elif left_over > expenses_so_far:
+                too_high = needed_netto 
+            needed_netto = too_low + (too_high - too_low)/2
+        ESt_this_month = ESt_this_month.quantize(decimal.Decimal('0.00'))
+        self.transfer_lines += [TransferLine(None, acc_est, ESt_this_month, '€')]
+        kk_minimum_income = 1131.67
+        kk_factor = decimal.Decimal(0.197)
+        kk_minimum_tax = decimal.Decimal(222.94).quantize(decimal.Decimal('0.00'))
+        kk_add_so_far = account_sums[acc_kk_add]['€'] if acc_kk_add in account_sums.keys() else 0
+        kk_add = needed_netto / (1 - kk_factor) - needed_netto - kk_minimum_tax
+        hit_kk_minimum_income_limit = False
+        if kk_add_so_far + kk_add < 0:
+            hit_kk_minimum_income_limit = True 
+            kk_add_uncorrect = kk_add
+            kk_add = -(kk_add + kk_add_so_far) 
+        kk_add = decimal.Decimal(kk_add).quantize(decimal.Decimal('0.00'))
+        self.transfer_lines += [TransferLine(None, acc_kk_minimum, kk_minimum_tx, '€')]
+        self.transfer_lines += [TransferLine(None, acc_kk_add, kk_add, '€')]
+        diff = - last_monthbreak_est + ESt_this_month - last_monthbreak_kk_add + kk_add
+        if not finish:
+            diff += kk_minimum_tax
+        final_minus = expenses_so_far - old_needed_income_before_anything + diff
+        diff += kk_minimum_tax
+        final_minus = expenses_so_far - old_needed_income_before_anything + diff
+        self.transfer_lines += [TransferLine(None, acc_assets, -diff, '€')]
+        self.transfer_lines += [TransferLine(None, acc_assets, final_minus, '€')]
+        self.transfer_lines += [TransferLine(None, acc_buffer, -final_minus, '€')]
+
+    def for_writing(self):
+        lines = [f'{self.date} {self.description}']
+        if self.top_comment is not None and self.top_comment.rstrip() != '':
+            lines[0] += f' ; {self.top_comment}'
+        for line in self.transfer_lines:
+            lines += [line.for_writing()]
+        return lines
+
+    @property
+    def comment_cols(self):
+        return max(20, len(self.top_comment))
+
+
+# class Booking:
+# 
+#     def __init__(self, date_string, description, booking_lines, start_line, process=True):
+#         self.date_string = date_string
+#         self.description = description
+#         self.lines = booking_lines
+#         self.start_line = start_line
+#         if process:
+#             self.validate_booking_lines()
+#             self.sink = {}
+#             self.account_changes = self.parse_booking_lines_to_account_changes()
+# 
+#     def validate_booking_lines(self):
+#         prefix = f"booking at line {self.start_line}"
+#         sums = {}
+#         empty_values = 0
+#         for line in self.lines[1:]:
+#             if line == '':
+#                 continue
+#             _, amount, currency = line
+#             if amount is None:
+#                 if empty_values > 0:
+#                     raise PlomException(f"{prefix} relates more than one empty value of same currency {currency}")
+#                 empty_values += 1
+#                 continue
+#             if currency not in sums:
+#                 sums[currency] = 0
+#             sums[currency] += amount
+#         if empty_values == 0:
+#             for k, v in sums.items():
+#                 if v != 0:
+#                     raise PlomException(f"{prefix} does not add up to zero / {k} {v}")
+#         else:
+#             sinkable = False
+#             for k, v in sums.items():
+#                 if v != 0:
+#                     sinkable = True
+#             if not sinkable:
+#                 raise PlomException(f"{prefix} has empty value that cannot be filled")
+# 
+#     def parse_booking_lines_to_account_changes(self):
+#         account_changes = {}
+#         debt = {}
+#         sink_account = None
+#         for line in self.lines[1:]:
+#             if line == '':
+#                 continue
+#             account, amount, currency = line
+#             if amount is None:
+#                 sink_account = account
+#                 continue
+#             apply_booking_to_account_balances(account_changes, account, currency, amount)
+#             if currency not in debt:
+#                 debt[currency] = amount
+#             else:
+#                 debt[currency] += amount
+#         if sink_account:
+#             for currency, amount in debt.items():
+#                 apply_booking_to_account_balances(account_changes, sink_account, currency, -amount)
+#                 self.sink[currency] = -amount
+#         return account_changes
 
 
 
 class LedgerDB(PlomDB):
 
-    def __init__(self, prefix):
+    def __init__(self, prefix, ignore_editable_exceptions=False):
         self.prefix = prefix 
         self.bookings = []
         self.comments = []
         self.real_lines = []
         super().__init__(db_path)
-        ret = parse_lines(self.real_lines)
-        self.bookings += ret[0]
-        self.comments += ret[1]
+        self.bookings = parse_lines2(self.real_lines, ignore_editable_exceptions)
 
     def read_db_file(self, f):
-        self.real_lines += [l.rstrip() for l in f.readlines()]
+        self.real_lines += [l.rstrip() for l in f.readlines()]  # TODO is this necessary? (parser already removes lines?)
+
+    # def get_lines(self, start, end):
+    #     return self.real_lines[start:end]
+
+    # def write_db(self, text, mode='w'):
+    #     if text[-1] != '\n':
+    #         text += '\n'
+    #     self.write_text_to_db(text)
+
+    # def insert_at_date(self, lines, date):
+    #     start_at = 0 
+    #     if len(self.bookings) > 0:
+    #         if date >= self.bookings[-1].date_string:
+    #             start_at = len(self.real_lines)
+    #             lines = [''] + lines
+    #         else:
+    #             for b in self.bookings:
+    #                 if b.date_string == date:
+    #                     start_at = b.start_line 
+    #                 elif b.date_string > date:
+    #                     start_at = b.start_line 
+    #                     break
+    #             lines += ['']  # DEBUG is new
+    #     return self.write_lines_in_total_lines_at(self.real_lines, start_at, lines)
+
+    # def update(self, start, end, lines, date):
+    #     remaining_lines = self.real_lines[:start] + self.real_lines[end:]
+    #     n_original_lines = end - start
+    #     start_at = len(remaining_lines)
+    #     for b in self.bookings:
+    #         if b.date_string == date:
+    #             if start_at == len(remaining_lines) or b.start_line == start:
+    #                 start_at = b.start_line 
+    #                 if b.start_line > start:
+    #                     start_at -= n_original_lines
+    #         elif b.date_string > date:
+    #             break
+    #     # print("DEBUG update start_at", start_at, "len(remaining_lines)", len(remaining_lines), "len(self.real_lines)", len(self.real_lines), "end", end)
+    #     if start_at != 0 and end != len(self.real_lines) and start_at == len(remaining_lines):
+    #         # Add empty predecessor line if appending.
+    #         lines = [''] + lines
+    #     return self.write_lines_in_total_lines_at(remaining_lines, start_at, lines)
 
-    def get_lines(self, start, end):
-        return self.real_lines[start:end]
+    # def write_lines_in_total_lines_at(self, total_lines, start_at, lines):
+    #     # total_lines = total_lines[:start_at] + lines + [''] + total_lines[start_at:]
+    #     total_lines = total_lines[:start_at] + lines + total_lines[start_at:]
+    #     _, _ = parse_lines(lines)
+    #     text = '\n'.join(total_lines)
+    #     self.write_db(text)
+    #     return start_at
 
-    def write_db(self, text, mode='w'):
-        if text[-1] != '\n':
-            text += '\n'
-        self.write_text_to_db(text)
+    # def get_nth_for_booking_of_start_line(self, start_line):
+    #     nth = 0
+    #     for b in self.bookings:
+    #         if b.start_line >= start_line:
+    #             break
+    #         nth += 1
+    #     return nth
 
-    def insert_at_date(self, lines, date):
-        start_at = 0 
+    def insert_booking_at_date(self, booking):
+        place_at = 0
         if len(self.bookings) > 0:
-            if date >= self.bookings[-1].date_string:
-                start_at = len(self.real_lines)
-                lines = [''] + lines
-            else:
-                for b in self.bookings:
-                    if b.date_string == date:
-                        start_at = b.start_line 
-                    elif b.date_string > date:
-                        start_at = b.start_line 
-                        break
-                lines += ['']  # DEBUG is new
-        return self.write_lines_in_total_lines_at(self.real_lines, start_at, lines)
-
-    def update(self, start, end, lines, date):
-        remaining_lines = self.real_lines[:start] + self.real_lines[end:]
-        n_original_lines = end - start
-        start_at = len(remaining_lines)
-        for b in self.bookings:
-            if b.date_string == date:
-                if start_at == len(remaining_lines) or b.start_line == start:
-                    start_at = b.start_line 
-                    if b.start_line > start:
-                        start_at -= n_original_lines
-            elif b.date_string > date:
-                break
-        # print("DEBUG update start_at", start_at, "len(remaining_lines)", len(remaining_lines), "len(self.real_lines)", len(self.real_lines), "end", end)
-        if start_at != 0 and end != len(self.real_lines) and start_at == len(remaining_lines):
-            # Add empty predecessor line if appending.
-            lines = [''] + lines
-        return self.write_lines_in_total_lines_at(remaining_lines, start_at, lines)
-
-    def write_lines_in_total_lines_at(self, total_lines, start_at, lines):
-        # total_lines = total_lines[:start_at] + lines + [''] + total_lines[start_at:]
-        total_lines = total_lines[:start_at] + lines + total_lines[start_at:]
-        _, _ = parse_lines(lines)
-        text = '\n'.join(total_lines)
-        self.write_db(text)
-        return start_at
-
-    def get_nth_for_booking_of_start_line(self, start_line):
-        nth = 0
-        for b in self.bookings:
-            if b.start_line >= start_line:
-                break
-            nth += 1
-        return nth
+            for i, iterated_booking in enumerate(self.bookings):
+                if booking.date < iterated_booking.date:
+                    break
+                elif booking.date == iterated_booking.date:
+                    place_at = i
+                    break
+                else:
+                    place_at = i + 1
+        self.bookings = self.bookings[:place_at] + [booking] + self.bookings[place_at:]
 
     def add_taxes(self, lines, finish=False):
         ret = []
@@ -524,230 +893,300 @@ class LedgerDB(PlomDB):
             ret += [f'  {acc_buffer}  {-final_minus} € ; assume as to earn in year: {acc_buffer} + {12 - months_passed - 1} * this = {year_needed}']
         return ret
 
-    def add_mirror(self, lines):
-        ret = []
-        bookings, _ = parse_lines(lines)
-        booking = bookings[0]
-        for line in booking.lines[1:]:
-            ret += [f'?  {-line[1]} {line[2]}']
-        return ret
+    # def add_mirror(self, lines):
+    #     ret = []
+    #     bookings, _ = parse_lines(lines)
+    #     booking = bookings[0]
+    #     for line in booking.lines[1:]:
+    #         ret += [f'?  {-line[1]} {line[2]}']
+    #     return ret
 
     def ledger_as_html(self):
-        booking_tmpl = jinja2.Template(booking_html)
-        single_c_tmpl = jinja2.Template('<span class="comment">{{c|e}}</span><br />')  ##
-        elements_to_write = []
-        last_i = i = 0  ##
         for nth, booking in enumerate(self.bookings):
-            move_up = nth > 0 and self.bookings[nth - 1].date_string == booking.date_string
-            move_down = nth < len(self.bookings) - 1 and self.bookings[nth + 1].date_string == booking.date_string
-            booking_end = last_i = booking.start_line + len(booking.lines)
-            booking_lines = []
-            i = booking.start_line  ##
-            elements_to_write += [single_c_tmpl.render(c=c) for c in self.comments[last_i:i] if c != '']  ##
-            for booking_line in booking.lines[1:]:
-                 i += 1  ##
-                 comment = self.comments[i]  ##
-                 if booking_line == '':
-                     booking_lines += [{'acc': None, 'money': None, 'comment': comment}]  ##
-                     continue
-                 account = booking_line[0]
-                 money = ''
-                 if booking_line[1] is not None:
-                     money = f'{booking_line[1]} {booking_line[2]}'
-                 booking_lines += [{'acc': booking_line[0], 'money':money, 'comment':comment}]  ##
-            elements_to_write += [booking_tmpl.render(
-                prefix=self.prefix,
-                nth=nth,
-                start=booking.start_line,
-                end=booking_end,
-                date=booking.date_string,
-                desc=booking.description,
-                head_comment=self.comments[booking.start_line],
-                move_up=move_up,
-                move_down=move_down,
-                booking_lines = booking_lines)]
-        elements_to_write += [single_c_tmpl.render(c=c) for c in self.comments[last_i:] if c != '']  #
-        return '\n'.join(elements_to_write)
+            booking.can_up = nth > 0 and self.bookings[nth - 1].date == booking.date
+            booking.can_down = nth < len(self.bookings) - 1 and self.bookings[nth + 1].date == booking.date
+        return j2env.get_template('ledger.html').render(bookings=self.bookings)
+
+    # def ledger_as_html(self):
+    #     booking_tmpl = jinja2.Template(booking_html)
+    #     single_c_tmpl = jinja2.Template('<span class="comment">{{c|e}}</span><br />')  ##
+    #     elements_to_write = []
+    #     last_i = i = 0  ##
+    #     for nth, booking in enumerate(self.bookings):
+    #         move_up = nth > 0 and self.bookings[nth - 1].date_string == booking.date_string
+    #         move_down = nth < len(self.bookings) - 1 and self.bookings[nth + 1].date_string == booking.date_string
+    #         booking_end = last_i = booking.start_line + len(booking.lines)
+    #         booking_lines = []
+    #         i = booking.start_line  ##
+    #         elements_to_write += [single_c_tmpl.render(c=c) for c in self.comments[last_i:i] if c != '']  ##
+    #         for booking_line in booking.lines[1:]:
+    #              i += 1  ##
+    #              comment = self.comments[i]  ##
+    #              if booking_line == '':
+    #                  booking_lines += [{'acc': None, 'money': None, 'comment': comment}]  ##
+    #                  continue
+    #              account = booking_line[0]
+    #              money = ''
+    #              if booking_line[1] is not None:
+    #                  money = f'{booking_line[1]} {booking_line[2]}'
+    #              booking_lines += [{'acc': booking_line[0], 'money':money, 'comment':comment}]  ##
+    #         elements_to_write += [booking_tmpl.render(
+    #             prefix=self.prefix,
+    #             nth=nth,
+    #             start=booking.start_line,
+    #             end=booking_end,
+    #             date=booking.date_string,
+    #             desc=booking.description,
+    #             head_comment=self.comments[booking.start_line],
+    #             move_up=move_up,
+    #             move_down=move_down,
+    #             booking_lines = booking_lines)]
+    #     elements_to_write += [single_c_tmpl.render(c=c) for c in self.comments[last_i:] if c != '']  #
+    #     return '\n'.join(elements_to_write)
 
     def balance_as_html(self, until=None):
-        bookings = self.bookings[:until if until is None else int(until)]
-        lines = []
-        account_tree, account_sums = bookings_to_account_tree(bookings)
-        def print_subtree(lines, indent, node, subtree, path):
-            line = f"{indent}{node}"
-            n_tabs = 5 - (len(line) // 8)
-            line += n_tabs * "\t"
-            if "€" in account_sums[path + node].keys():
-                amount = account_sums[path + node]["€"]
-                line += f"{amount:9.2f} €\t"
-            else:
-                line += f"\t\t"
-            for currency, amount in account_sums[path + node].items():
-                if currency != '€' and amount != 0:
-                    line += f"{amount:5.2f} {currency}\t"
-            lines += [line]
-            indent += "  "
-            for k, v in sorted(subtree.items()):
-                print_subtree(lines, indent, k, v, path + node + ":")
-        for k, v in sorted(account_tree.items()):
-            print_subtree(lines, "", k, v, "")
-        content = "\n".join(lines)
-        return f"<pre>{content}</pre>"
-
-    def add_free(self, start=0, end=0, copy=False):
-        tmpl = jinja2.Template(add_form_header + add_free_html + add_form_footer) 
-        lines = self.get_lines(start, end)
-        if copy:
-            start = end = 0
-        return tmpl.render(action=self.prefix + '/add_free', start=start, end=end, lines=lines)
-
-    def add_structured(self, start=0, end=0, copy=False, temp_lines=[], add_empty_line=None):
-        tmpl = jinja2.Template(add_form_header + add_structured_html + add_form_footer) 
-        lines = temp_lines if len(''.join(temp_lines)) > 0 else self.get_lines(start, end)
-        bookings, comments = parse_lines(lines, validate_bookings=False)
-        if len(bookings) > 1:
-            raise PlomException('can only structurally edit single Booking')
-        if add_empty_line is not None:
-            comments = comments[:add_empty_line+1] + [''] + comments[add_empty_line+1:]
-            booking = bookings[0]
-            booking.lines = booking.lines[:add_empty_line+1] + [''] + booking.lines[add_empty_line+1:]
-        action = self.prefix + '/add_structured'
-        datalist_sets = {'descriptions': set(), 'accounts': set(), 'currencies': set()}
-        for b in self.bookings:
-            datalist_sets['descriptions'].add(b.description)
-            for account, moneys in b.account_changes.items():
-                datalist_sets['accounts'].add(account)
-                for currency in moneys.keys():
-                    datalist_sets['currencies'].add(currency)
-        content = ''
-        today = str(datetime.now())[:10]
-        booking_lines = []
-        if copy:
-            start = end = 0
-        desc = head_comment = ''
-        if len(bookings) == 0:
-            date=today
+        bookings = self.bookings[:(until if until is None else int(until)+1)]
+        account_trunk = Account('', None)
+        accounts = {account_trunk.full_name: account_trunk}
+        for booking in bookings:
+            for full_account_name, moneys in booking.account_changes.items():
+                toks = full_account_name.split(':')
+                path = [] 
+                for tok in toks:
+                    parent_name = ':'.join(path) 
+                    path += [tok] 
+                    account_name = ':'.join(path)
+                    if not account_name in accounts.keys():
+                        accounts[account_name] = Account(own_name=tok, parent=accounts[parent_name])
+                accounts[full_account_name].add_wealth(moneys)
+        class Node:
+            def __init__(self, indent, name, moneys):
+                self.indent = indent
+                self.name = name
+                self.moneys = moneys.money_dict
+        nodes = []
+        def walk_tree(nodes, indent, account):
+            nodes += [Node(indent, account.own_name, account.full_moneys)]
+            for child in account.children:
+                walk_tree(nodes, indent+1, child)
+        for acc in account_trunk.children:
+            walk_tree(nodes, 0, acc)
+        return j2env.get_template('balance.html').render(nodes=nodes)
+
+    # def balance_as_html(self, until=None):
+    #     bookings = self.bookings[:until if until is None else int(until)]
+    #     lines = []
+    #     account_tree, account_sums = bookings_to_account_tree(bookings)
+    #     def print_subtree(lines, indent, node, subtree, path):
+    #         line = f"{indent}{node}"
+    #         n_tabs = 5 - (len(line) // 8)
+    #         line += n_tabs * "\t"
+    #         if "€" in account_sums[path + node].keys():
+    #             amount = account_sums[path + node]["€"]
+    #             line += f"{amount:9.2f} €\t"
+    #         else:
+    #             line += f"\t\t"
+    #         for currency, amount in account_sums[path + node].items():
+    #             if currency != '€' and amount != 0:
+    #                 line += f"{amount:5.2f} {currency}\t"
+    #         lines += [line]
+    #         indent += "  "
+    #         for k, v in sorted(subtree.items()):
+    #             print_subtree(lines, indent, k, v, path + node + ":")
+    #     for k, v in sorted(account_tree.items()):
+    #         print_subtree(lines, "", k, v, "")
+    #     content = "\n".join(lines)
+    #     return f"<pre>{content}</pre>"
+
+    def edit(self, index, sent=None, error_msg=None, edit_mode='table'):
+        accounts = set() 
+        if sent or -1 == index:
+            content = sent if sent else ([] if 'textarea'==edit_mode else None)
         else:
-            booking = bookings[0]
-            desc = booking.description
-            date = today if copy else booking.date_string
-            head_comment=comments[0]
-            for i in range(1, len(comments)):
-                account = amount = currency = ''
-                if i < len(booking.lines) and booking.lines[i] != '':
-                    account = booking.lines[i][0]
-                    amount = booking.lines[i][1]
-                    currency = booking.lines[i][2]
-                booking_lines += [{
-                        'i': i,
-                        'acc': account,
-                        'amt': amount,
-                        'curr': currency if currency else '€',
-                        'comment': comments[i],
-                        'comm_cols': len(comments[i])}]
-        for i in range(len(comments), len(comments) + 8):
-            booking_lines += [{'i': i, 'acc': '', 'amt': '', 'curr': '€', 'comment': ''}]
-        content += tmpl.render(
-                action=action,
-                date=date,
-                desc=desc,
-                head_comment=head_comment,
-                booking_lines=booking_lines,
-                datalist_sets=datalist_sets,
-                start=start,
-                end=end)
-        return content
-
-    def move_up(self, start, end):
-        prev_booking = None
-        for redir_nth, b in enumerate(self.bookings):
-            if b.start_line >= start:
-                break
-            prev_booking = b
-        start_at = prev_booking.start_line 
-        self.make_move(start, end, start_at)
-        return redir_nth - 1
-
-    def move_down(self, start, end):
-        next_booking = None
-        for redir_nth, b in enumerate(self.bookings):
-            if b.start_line > start:
-                next_booking = b
-                break
-        # start_at = next_booking.start_line + len(next_booking.lines) - (end - start) + 1 
-        # self.make_move(start, end, start_at-1)
-        start_at = next_booking.start_line + len(next_booking.lines) - (end - start)
-        print("DEBUG", start, end, start_at)
-        self.make_move(start, end, start_at)
-        return redir_nth
-
-    def make_move(self, start, end, start_at):
-        # FIXME currently broken due to changed self.write_lines_in_total_lines_at, easy fix would be lines += [""] maybe?
-        lines = self.get_lines(start, end)
-        if start == 0:
-            total_lines = self.real_lines[end+1:]
-            lines = [''] + lines
-            start_at += 1
-        else: 
-            total_lines = self.real_lines[:start-1] + self.real_lines[end:]  # -1 because we reduce the original position's two empty limit lines to one in-between line
-            lines += ['']
-        self.write_lines_in_total_lines_at(total_lines, start_at, lines)
-
-    def booking_lines_from_postvars(self, postvars):
-        add_empty_line = None
-        date = postvars['date'][0]
-        description = postvars['description'][0]
-        start_comment = postvars['line_0_comment'][0]
-        start_line = f'{date} {description}'
-        if start_comment.rstrip() != '':
-            start_line += f' ; {start_comment}' 
-        lines = [start_line]
-        if 'line_0_add' in postvars.keys():
-            add_empty_line = 0
-        i = j = 1
-        while f'line_{i}_comment' in postvars.keys():
-            if f'line_{i}_delete' in postvars.keys():
-                i += 1
-                continue
-            elif f'line_{i}_delete_after' in postvars.keys():
-                break 
-            elif f'line_{i}_add' in postvars.keys():
-                add_empty_line = j
-            account = postvars[f'line_{i}_account'][0]
-            amount = postvars[f'line_{i}_amount'][0]
-            currency = postvars[f'line_{i}_currency'][0]
-            comment = postvars[f'line_{i}_comment'][0]
-            i += 1
-            new_main = f'  {account}  {amount}'
-            if '' == new_main.rstrip() == comment.rstrip():  # don't write empty lines, ignore currency if nothing else set
-                continue
-            if len(amount.rstrip()) > 0:
-                new_main += f' {currency}'
-            j += 1
-            new_line = new_main
-            if comment.rstrip() != '':
-                new_line += f'  ; {comment}'
-            lines += [new_line]
-        if 'add_sink' in postvars.keys():
-            temp_lines = lines.copy() + ['_']
-            try:
-                temp_bookings, _ = parse_lines(temp_lines)
-                for currency in temp_bookings[0].sink:
-                    amount = temp_bookings[0].sink[currency]
-                    # lines += [f'Assets  {amount:.2f} {currency}']
-                    lines += [f'Assets  {amount} {currency}']
-            except PlomException:
-                pass
-        elif 'add_taxes' in postvars.keys():
-            lines += self.add_taxes(lines, finish=False)
-        elif 'add_taxes2' in postvars.keys():
-            lines += self.add_taxes(lines, finish=True)
-        elif 'replace' in postvars.keys():
-            for i, line in enumerate(lines):
-                lines[i] = line.replace(postvars['replace_from'][0], postvars['replace_to'][0])
-        elif 'add_mirror' in postvars.keys():
-            lines += self.add_mirror(lines)
-        return lines, add_empty_line
+            content = self.bookings[index]
+        if 'textarea' == edit_mode and content:
+            content = content.for_writing()
+        else:
+            for booking in self.bookings:
+                for transfer_line in booking.transfer_lines:
+                    accounts.add(transfer_line.account)
+        return j2env.get_template('edit.html').render(content=content, index=index, error_msg=error_msg, edit_mode=edit_mode, accounts=accounts)
+
+    # def add_free(self, start=0, end=0, copy=False):
+    #     tmpl = jinja2.Template(add_form_header + add_free_html + add_form_footer) 
+    #     lines = self.get_lines(start, end)
+    #     if copy:
+    #         start = end = 0
+    #     return tmpl.render(action=self.prefix + '/add_free', start=start, end=end, lines=lines)
+
+    # def add_structured(self, start=0, end=0, copy=False, temp_lines=[], add_empty_line=None):
+    #     tmpl = jinja2.Template(add_form_header + add_structured_html + add_form_footer) 
+    #     lines = temp_lines if len(''.join(temp_lines)) > 0 else self.get_lines(start, end)
+    #     bookings, comments = parse_lines(lines, validate_bookings=False)
+    #     if len(bookings) > 1:
+    #         raise PlomException('can only structurally edit single Booking')
+    #     if add_empty_line is not None:
+    #         comments = comments[:add_empty_line+1] + [''] + comments[add_empty_line+1:]
+    #         booking = bookings[0]
+    #         booking.lines = booking.lines[:add_empty_line+1] + [''] + booking.lines[add_empty_line+1:]
+    #     action = self.prefix + '/add_structured'
+    #     datalist_sets = {'descriptions': set(), 'accounts': set(), 'currencies': set()}
+    #     for b in self.bookings:
+    #         datalist_sets['descriptions'].add(b.description)
+    #         for account, moneys in b.account_changes.items():
+    #             datalist_sets['accounts'].add(account)
+    #             for currency in moneys.keys():
+    #                 datalist_sets['currencies'].add(currency)
+    #     content = ''
+    #     today = str(datetime.now())[:10]
+    #     booking_lines = []
+    #     if copy:
+    #         start = end = 0
+    #     desc = head_comment = ''
+    #     if len(bookings) == 0:
+    #         date=today
+    #     else:
+    #         booking = bookings[0]
+    #         desc = booking.description
+    #         date = today if copy else booking.date_string
+    #         head_comment=comments[0]
+    #         for i in range(1, len(comments)):
+    #             account = amount = currency = ''
+    #             if i < len(booking.lines) and booking.lines[i] != '':
+    #                 account = booking.lines[i][0]
+    #                 amount = booking.lines[i][1]
+    #                 currency = booking.lines[i][2]
+    #             booking_lines += [{
+    #                     'i': i,
+    #                     'acc': account,
+    #                     'amt': amount,
+    #                     'curr': currency if currency else '€',
+    #                     'comment': comments[i],
+    #                     'comm_cols': len(comments[i])}]
+    #     for i in range(len(comments), len(comments) + 8):
+    #         booking_lines += [{'i': i, 'acc': '', 'amt': '', 'curr': '€', 'comment': ''}]
+    #     content += tmpl.render(
+    #             action=action,
+    #             date=date,
+    #             desc=desc,
+    #             head_comment=head_comment,
+    #             booking_lines=booking_lines,
+    #             datalist_sets=datalist_sets,
+    #             start=start,
+    #             end=end)
+    #     return content
+
+    def move_up(self, nth):
+        return self.move(nth, -1) 
+
+    def move_down(self, nth):
+        return self.move(nth, +1) 
+
+    def move(self, nth, direction):
+        to_move = self.bookings[nth]
+        swap_nth = nth+1*(direction)
+        to_swap = self.bookings[swap_nth]
+        self.bookings[nth] = to_swap 
+        self.bookings[nth+1*(direction)] = to_move 
+        return swap_nth
+
+    def write_db(self):
+        lines = []
+        for i, booking in enumerate(self.bookings):
+            if i > 0:
+                lines += ['']
+            lines += booking.for_writing()
+        self.write_text_to_db('\n'.join(lines) + '\n')
+
+    # def move_up(self, start, end):
+    #     prev_booking = None
+    #     for redir_nth, b in enumerate(self.bookings):
+    #         if b.start_line >= start:
+    #             break
+    #         prev_booking = b
+    #     start_at = prev_booking.start_line 
+    #     self.make_move(start, end, start_at)
+    #     return redir_nth - 1
+
+    # def move_down(self, start, end):
+    #     next_booking = None
+    #     for redir_nth, b in enumerate(self.bookings):
+    #         if b.start_line > start:
+    #             next_booking = b
+    #             break
+    #     # start_at = next_booking.start_line + len(next_booking.lines) - (end - start) + 1 
+    #     # self.make_move(start, end, start_at-1)
+    #     start_at = next_booking.start_line + len(next_booking.lines) - (end - start)
+    #     self.make_move(start, end, start_at)
+    #     return redir_nth
+
+    # def make_move(self, start, end, start_at):
+    #     # FIXME currently broken due to changed self.write_lines_in_total_lines_at, easy fix would be lines += [""] maybe?
+    #     lines = self.get_lines(start, end)
+    #     if start == 0:
+    #         total_lines = self.real_lines[end+1:]
+    #         lines = [''] + lines
+    #         start_at += 1
+    #     else: 
+    #         total_lines = self.real_lines[:start-1] + self.real_lines[end:]  # -1 because we reduce the original position's two empty limit lines to one in-between line
+    #         lines += ['']
+    #     self.write_lines_in_total_lines_at(total_lines, start_at, lines)
+
+    # def booking_lines_from_postvars(self, postvars):
+    #     add_empty_line = None
+    #     date = postvars['date'][0]
+    #     description = postvars['description'][0]
+    #     start_comment = postvars['line_0_comment'][0]
+    #     start_line = f'{date} {description}'
+    #     if start_comment.rstrip() != '':
+    #         start_line += f' ; {start_comment}' 
+    #     lines = [start_line]
+    #     if 'line_0_add' in postvars.keys():
+    #         add_empty_line = 0
+    #     i = j = 1
+    #     while f'line_{i}_comment' in postvars.keys():
+    #         if f'line_{i}_delete' in postvars.keys():
+    #             i += 1
+    #             continue
+    #         elif f'line_{i}_delete_after' in postvars.keys():
+    #             break 
+    #         elif f'line_{i}_add' in postvars.keys():
+    #             add_empty_line = j
+    #         account = postvars[f'line_{i}_account'][0]
+    #         amount = postvars[f'line_{i}_amount'][0]
+    #         currency = postvars[f'line_{i}_currency'][0]
+    #         comment = postvars[f'line_{i}_comment'][0]
+    #         i += 1
+    #         new_main = f'  {account}  {amount}'
+    #         if '' == new_main.rstrip() == comment.rstrip():  # don't write empty lines, ignore currency if nothing else set
+    #             continue
+    #         if len(amount.rstrip()) > 0:
+    #             new_main += f' {currency}'
+    #         j += 1
+    #         new_line = new_main
+    #         if comment.rstrip() != '':
+    #             new_line += f'  ; {comment}'
+    #         lines += [new_line]
+    #     if 'add_sink' in postvars.keys():
+    #         temp_lines = lines.copy() + ['_']
+    #         try:
+    #             temp_bookings, _ = parse_lines(temp_lines)
+    #             for currency in temp_bookings[0].sink:
+    #                 amount = temp_bookings[0].sink[currency]
+    #                 # lines += [f'Assets  {amount:.2f} {currency}']
+    #                 lines += [f'Assets  {amount} {currency}']
+    #         except PlomException:
+    #             pass
+    #     elif 'add_taxes' in postvars.keys():
+    #         lines += self.add_taxes(lines, finish=False)
+    #     elif 'add_taxes2' in postvars.keys():
+    #         lines += self.add_taxes(lines, finish=True)
+    #     elif 'replace' in postvars.keys():
+    #         for i, line in enumerate(lines):
+    #             lines[i] = line.replace(postvars['replace_from'][0], postvars['replace_to'][0])
+    #     elif 'add_mirror' in postvars.keys():
+    #         lines += self.add_mirror(lines)
+    #     return lines, add_empty_line
 
 
 
@@ -756,7 +1195,7 @@ class LedgerHandler(PlomHandler):
     def app_init(self, handler):
         default_path = '/ledger'
         handler.add_route('GET', default_path, self.forward_gets) 
-        handler.add_route('POST', default_path, self.forward_posts) 
+        handler.add_route('POST', default_path, self.forward_posts)
         return 'ledger', default_path 
 
     def do_POST(self):
@@ -764,88 +1203,133 @@ class LedgerHandler(PlomHandler):
 
     def forward_posts(self):
         prefix = self.apps['ledger'] if hasattr(self, 'apps') else '' 
-        parsed_url = urlparse(self.path)
         length = int(self.headers['content-length'])
         postvars = parse_qs(self.rfile.read(length).decode(), keep_blank_values=1)
-        start = int(postvars['start'][0])
-        end = int(postvars['end'][0])
-        print("DEBUG start, end", start, end)
-        db = LedgerDB(prefix)
-        add_empty_line = None
-        lines = []
-        # get inputs
-        if prefix + '/add_structured' == parsed_url.path and not 'revert' in postvars.keys():
-            lines, add_empty_line = db.booking_lines_from_postvars(postvars) 
-        elif prefix + '/add_free' == parsed_url.path and not 'revert' in postvars.keys():
-            lines = postvars['booking'][0].splitlines()
-        # validate where appropriate
-        if ('save' in postvars.keys()) or ('check' in postvars.keys()):
-            _, _ = parse_lines(lines)
-        # if saving, process where to and where to redirect after
-        if 'save' in postvars.keys():
-            last_date = str(datetime.now())[:10]
-            if len(db.bookings) > 0:
-                last_date = db.bookings[-1].date_string
-            target_date = last_date[:] 
-            first_line_tokens = lines[0].split() if len(lines) > 0 else ''
-            first_token = first_line_tokens[0] if len(first_line_tokens) > 0 else ''
-            try:
-                datetime.strptime(first_token, '%Y-%m-%d')
-                target_date = first_token
-            except ValueError:
-                 pass
-            if start == end == 0:
-                start = db.insert_at_date(lines, target_date)
-                nth = db.get_nth_for_booking_of_start_line(start) 
+        db = LedgerDB(prefix, ignore_editable_exceptions=True)
+        index = 0
+        parsed_url = urlparse(self.path)
+        for string in {'save', 'copy', 'check', 'mirror', 'fill sink', 'as textarea', 'as table', 'move up', 'move down', 'add taxes'}:
+            if string in postvars.keys():
+                submit_button = string
+                break
+        if prefix + '/ledger' == parsed_url.path:
+            if submit_button == 'move up':
+                index = db.move_up(int(postvars['move up'][0]))
+            elif submit_button == 'move down':
+                index = db.move_down(int(postvars['move down'][0]))
+        elif prefix + '/edit' == parsed_url.path:
+            index = int(postvars['index'][0])
+            starts_at = '?' if index == -1 else db.bookings[index].starts_at
+            edit_mode = postvars['edit_mode'][0]
+            validate = submit_button in {'save', 'copy', 'check'}
+            if 'textarea' == edit_mode:
+                lines = postvars['booking'][0].rstrip().split('\n')
+                booking = Booking(lines, starts_at, validate=validate)
             else:
-                new_start = db.update(start, end, lines, target_date)
-                print("DEBUG save", new_start, start, end, lines)
-                nth = db.get_nth_for_booking_of_start_line(new_start)
-                if new_start > start: 
-                    nth -= 1 
-            self.redirect(prefix + f'/#{nth}')
-        # otherwise just re-build editing form
-        else:
-            if prefix + '/add_structured' == parsed_url.path: 
-                edit_content = db.add_structured(start, end, temp_lines=lines, add_empty_line=add_empty_line)
+                booking = Booking.from_postvars(postvars, starts_at, validate)
+            if submit_button in {'save', 'copy'}:
+                if index != -1 and submit_button != 'copy':
+                     if booking.date == db.bookings[index].date:
+                        db.bookings[index] = booking 
+                        booking_is_placed = True
+                     else:
+                        db.bookings = db.bookings[:index] + db.bookings[index+1:]
+                        db.insert_booking_at_date(booking)
+                else: 
+                    db.insert_booking_at_date(booking)
             else:
-                edit_content = db.add_free(start, end)
-            header = jinja2.Template(html_head).render(prefix=prefix)
-            self.send_HTML(header + edit_content)
+                error_msg = None
+                if 'check' == submit_button:
+                    error_msg = 'All looks fine!'
+                elif 'mirror' == submit_button:
+                    booking.add_mirror()
+                elif 'fill sink' == submit_button:
+                    booking.fill_sink()
+                elif 'add taxes' == submit_button:
+                    booking.add_taxes()
+                elif submit_button in {'as textarea', 'as table'}:
+                    edit_mode = submit_button[len('as '):]
+                page = db.edit(index, booking, error_msg=error_msg, edit_mode=edit_mode)
+                self.send_HTML(page)
+                return
+        db.write_db() 
+        index = index if index >= 0 else len(db.bookings) - 1
+        self.redirect(prefix + f'/ledger#{index}')
+
+    # def forward_posts(self):
+    #     prefix = self.apps['ledger'] if hasattr(self, 'apps') else '' 
+    #     parsed_url = urlparse(self.path)
+    #     length = int(self.headers['content-length'])
+    #     postvars = parse_qs(self.rfile.read(length).decode(), keep_blank_values=1)
+    #     start = int(postvars['start'][0])
+    #     end = int(postvars['end'][0])
+    #     print("DEBUG start, end", start, end)
+    #     db = LedgerDB(prefix)
+    #     add_empty_line = None
+    #     lines = []
+    #     # get inputs
+    #     if prefix + '/add_structured' == parsed_url.path and not 'revert' in postvars.keys():
+    #         lines, add_empty_line = db.booking_lines_from_postvars(postvars) 
+    #     elif prefix + '/add_free' == parsed_url.path and not 'revert' in postvars.keys():
+    #         lines = postvars['booking'][0].splitlines()
+    #     # validate where appropriate
+    #     if ('save' in postvars.keys()) or ('check' in postvars.keys()):
+    #         _, _ = parse_lines(lines)
+    #     # if saving, process where to and where to redirect after
+    #     if 'save' in postvars.keys():
+    #         last_date = str(datetime.now())[:10]
+    #         if len(db.bookings) > 0:
+    #             last_date = db.bookings[-1].date_string
+    #         target_date = last_date[:] 
+    #         first_line_tokens = lines[0].split() if len(lines) > 0 else ''
+    #         first_token = first_line_tokens[0] if len(first_line_tokens) > 0 else ''
+    #         try:
+    #             datetime.strptime(first_token, '%Y-%m-%d')
+    #             target_date = first_token
+    #         except ValueError:
+    #              pass
+    #         if start == end == 0:
+    #             start = db.insert_at_date(lines, target_date)
+    #             nth = db.get_nth_for_booking_of_start_line(start) 
+    #         else:
+    #             new_start = db.update(start, end, lines, target_date)
+    #             print("DEBUG save", new_start, start, end, lines)
+    #             nth = db.get_nth_for_booking_of_start_line(new_start)
+    #             if new_start > start: 
+    #                 nth -= 1 
+    #         self.redirect(prefix + f'/#{nth}')
+    #     # otherwise just re-build editing form
+    #     else:
+    #         if prefix + '/add_structured' == parsed_url.path: 
+    #             edit_content = db.add_structured(start, end, temp_lines=lines, add_empty_line=add_empty_line)
+    #         else:
+    #             edit_content = db.add_free(start, end)
+    #         header = jinja2.Template(html_head).render(prefix=prefix)
+    #         self.send_HTML(header + edit_content)
 
     def do_GET(self):
         self.try_do(self.forward_gets)
 
     def forward_gets(self):
         prefix = self.apps['ledger'] if hasattr(self, 'apps') else '' 
+        try:
+            db = LedgerDB(prefix=prefix)
+        except EditableException as e:
+            db = LedgerDB(prefix=prefix, ignore_editable_exceptions=True)
+            page = db.edit(index=e.booking_index, error_msg=f'ERROR: {e}')
+            self.send_HTML(page)
+            return
         parsed_url = urlparse(self.path)
         params = parse_qs(parsed_url.query)
-        start = int(params.get('start', ['0'])[0])
-        end = int(params.get('end', ['0'])[0])
-        db = LedgerDB(prefix=prefix)
         if parsed_url.path == prefix + '/balance':
             stop = params.get('stop', [None])[0]
             page = db.balance_as_html(stop)
-        elif parsed_url.path == prefix + '/add_free':
-            page = db.add_free(start, end)
-        elif parsed_url.path == prefix + '/add_structured':
-            page = db.add_structured(start, end)
-        elif parsed_url.path == prefix + '/copy_free':
-            page = db.add_free(start, end, copy=True)
-        elif parsed_url.path == prefix + '/copy_structured':
-            page = db.add_structured(start, end, copy=True)
-        elif parsed_url.path == prefix + '/move_up':
-            nth = db.move_up(start, end)
-            self.redirect(prefix + f'/#{nth}')
-            return
-        elif parsed_url.path == prefix + '/move_down':
-            nth = db.move_down(start, end)
-            self.redirect(prefix + f'/#{nth}')
-            return
+        elif parsed_url.path == prefix + '/edit':
+            index = params.get('i', [-1])[0]
+            page = db.edit(int(index))
         else:
             page = db.ledger_as_html()
-        header = jinja2.Template(html_head).render(prefix=prefix)
-        self.send_HTML(header + page)
+        self.send_HTML(page)
 
 
 
diff --git a/todo.py b/todo.py
index 8c911fb..29c1226 100644
--- a/todo.py
+++ b/todo.py
@@ -309,29 +309,45 @@ class TodoDB(PlomDB):
             task_rows.sort(key=lambda r: False if not r['todo'] else True, reverse=True)
         elif task_sort == 'comment':
             task_rows.sort(key=lambda r: '' if not r['todo'] else r['todo'].comment, reverse=True)
-        return j2env.get_template('day.html').render(db=self, action=self.prefix+'/day', prev_date=prev_date_str, next_date=next_date_str, task_rows=task_rows, sort=task_sort)
+        done_tasks = []
+        for uuid, task in self.tasks.items():
+            if uuid in self.selected_day.todos.keys():
+                todo = self.selected_day.todos[uuid]
+                if todo.done:
+                    done_tasks += [todo]
+        done_tasks.sort(key=lambda t: t.effort, reverse=True)
+        return j2env.get_template('day.html').render(db=self, action=self.prefix+'/day', prev_date=prev_date_str, next_date=next_date_str, task_rows=task_rows, sort=task_sort, done_tasks=done_tasks)
 
     def show_calendar(self, start_date_str, end_date_str):
         self.t_filter_and = ['calendar']
         self.t_filter_not = ['deleted']
         self.set_visibilities()
         days_to_show = {}
-        todays_date = str(datetime.now())[:10]
-        target_start_str = start_date_str if start_date_str else sorted(self.days.keys())[0]
-        target_start = todays_date if target_start_str == 'today' else target_start_str
-        target_end_str = end_date_str if end_date_str else sorted(self.days.keys())[-1]
-        target_end = todays_date if target_end_str == 'today' else target_end_str
-        start_date = datetime.strptime(target_start, DATE_FORMAT)
-        end_date = datetime.strptime(target_end, DATE_FORMAT)
-        for n in range(int((end_date - start_date).days) + 1):
-            current_date_obj = start_date + timedelta(n)
-            current_date = current_date_obj.strftime(DATE_FORMAT)
-            if current_date not in self.days.keys():
-                days_to_show[current_date] = self.add_day()
+        todays_date_str = str(datetime.now())[:10]
+        todays_date_obj = datetime.strptime(todays_date_str, DATE_FORMAT) 
+        yesterdays_date_obj = todays_date_obj - timedelta(1)
+        yesterdays_date_str = yesterdays_date_obj.strftime(DATE_FORMAT) 
+        start_date_obj = datetime.strptime(sorted(self.days.keys())[0], DATE_FORMAT)
+        if start_date_str and len(start_date_str) > 0:
+            if start_date_str in {'today', 'yesterday'}:
+                start_date_obj = todays_date_obj if start_date_str == 'today' else yesterdays_date_obj
+            else:
+                start_date_obj = datetime.strptime(start_date_str, DATE_FORMAT)
+        end_date_obj = datetime.strptime(sorted(self.days.keys())[-1], DATE_FORMAT)
+        if end_date_str and len(end_date_str) > 0:
+            if end_date_str in {'today', 'yesterday'}:
+                end_date_obj = todays_date_obj if end_date_str == 'today' else yesterdays_date_obj
+            else:
+                end_date_obj = datetime.strptime(start_date_str, DATE_FORMAT)
+        for n in range(int((end_date_obj - start_date_obj).days) + 1):
+            current_date_obj = start_date_obj + timedelta(n)
+            current_date_str = current_date_obj.strftime(DATE_FORMAT)
+            if current_date_str not in self.days.keys():
+                days_to_show[current_date_str] = self.add_day()
             else:
-                days_to_show[current_date] = self.days[current_date]
-            days_to_show[current_date].weekday = datetime.strptime(current_date, DATE_FORMAT).strftime('%A')[:2]
-        return j2env.get_template('calendar.html').render(db=self, days=days_to_show, action=self.prefix+'/calendar', today=str(datetime.now())[:10], start_date=start_date_str, end_date=end_date_str)
+                days_to_show[current_date_str] = self.days[current_date_str]
+            days_to_show[current_date_str].weekday = datetime.strptime(current_date_str, DATE_FORMAT).strftime('%A')[:2]
+        return j2env.get_template('calendar.html').render(db=self, days=days_to_show, action=self.prefix+'/calendar', start_date=start_date_str, end_date=end_date_str)
 
     def show_todo(self, task_uuid, selected_date, referer):
         if selected_date not in self.days.keys():
@@ -552,7 +568,6 @@ class TodoHandler(PlomHandler):
                 page = 'cookie unset!'
         else:
             start_date = get_param('start')
-            start_date = start_date if start_date else 'today'
             end_date = get_param('end')
             page = db.show_calendar(start_date, end_date)
         if parsed_url.path != app_config['prefix'] + '/unset_cookie':
diff --git a/todo_templates/calendar.html b/todo_templates/calendar.html
index 8f0aa8e..5d49b5a 100644
--- a/todo_templates/calendar.html
+++ b/todo_templates/calendar.html
@@ -7,7 +7,7 @@ td.checkbox { width: 0.1em; height: 0.1em; padding: 0em; text-align: center; }
 {% block content %}
 <form action="{{action|e}}" method="POST">
 <p>
-from: <input name="start" {% if start_date %}value="{{ start_date }}"{% endif %} placeholder="{{ today }}" />
+from: <input name="start" {% if start_date %}value="{{ start_date }}"{% endif %} placeholder="yesterday" />
 to: <input name="end" {% if end_date %}value="{{ end_date }}"{% endif %} placeholder="2030-12-31" />
 <input type="submit" value="OK" />
 </p>
diff --git a/todo_templates/day.html b/todo_templates/day.html
index 4f5f1fc..6231aea 100644
--- a/todo_templates/day.html
+++ b/todo_templates/day.html
@@ -1,7 +1,7 @@
 {% extends 'base.html' %}
 {% block css %}
 table.alternating tr:nth-child(even) {
-    background-color: #f2f2f2;
+    background-color: #e2e2e2;
 }
 table.alternating tr:nth-child(odd) {
     background-color: #ffffff;
@@ -22,15 +22,26 @@ input[type="number"] { text-align: right; }
 </p>
 </form>
 
-<form id="form_to_watch" action="{{action|e}}" method="POST">
 <h3>edit day</h3>
+<form id="form_to_watch" action="{{action|e}}" method="POST">
 <p>
-<a href="{{db.prefix}}/day?selected_date={{prev_date}}">prev</a> | {{db.selected_date}} | <a href="{{db.prefix}}/day?selected_date={{next_date}}">next</a> | 
-{{ db.selected_day.todos_sum|round(2) }} ({{ db.selected_day.todos_sum2|round(2)}}) |
+| <a href="{{db.prefix}}/day?selected_date={{prev_date}}">prev</a> | {{db.selected_date}} | <a href="{{db.prefix}}/day?selected_date={{next_date}}">next</a> | 
 comment: <input name="day_comment" value="{{ db.selected_day.comment|e }}">
 <input type="submit" value="update">
 <input type="hidden" name="selected_date" value="{{ db.selected_date }}" />
 </p>
+<details>
+<summary>done: {{ db.selected_day.todos_sum|round(2) }} ({{ db.selected_day.todos_sum2|round(2)}})</summary>
+<table class="alternating">
+{% for todo in done_tasks %}
+<tr>
+<td>{{todo.task.current_title|e}}</td>
+<td>{{todo.effort}}</td>
+<td>{{todo.comment}}</td>
+</tr>
+{% endfor %}
+</table>
+</details>
 <table class="alternating">
 <tr>
 <th {% if sort=='title' %}class="desc"{% endif %}><a href="?sort=title">task</a></th>
diff --git a/todo_templates/tasks.html b/todo_templates/tasks.html
index 29ae64f..7d245dc 100644
--- a/todo_templates/tasks.html
+++ b/todo_templates/tasks.html
@@ -1,7 +1,7 @@
 {% extends 'base.html' %}
 {% block css %}
 table.alternating tr:nth-child(even) {
-    background-color: #f2f2f2;
+    background-color: #e2e2e2;
 }
 table.alternating tr:nth-child(odd) {
     background-color: #ffffff;
-- 
2.30.2