#! /usr/local/bin/python
# treepad.py

import sys, os, re, string

#
# constants
#
VERSION = "<Treepad version 2.7>"

#
# regexes
#
END_RE = re.compile(r'^<end node> ([^ ]+)$')

class Node:
    def __init__(self):
        self.title    = ""
        self.level    = 0
        self.article  = []
        self.children = []
        self.parent   = None
        self.end      = ""
    def __str__(self):
        return "%s/%d" % (self.title, self.level)
    def addchild(self, node):
        assert self.level == node.level-1 and node.parent is None
        node.parent = self
        self.children.append( node )
    def findparent(self, node):
        if self.level == (node.level-1): return self
        return self.parent.findparent(node)
    def writenode(self, fp):
        fp.write("dt=Text\n")
        fp.write("<node>\n")
        fp.write("%s\n" % self.title)
        fp.write("%s\n" % self.level)
        for line in self.article:
            fp.write("%s\n" % line)
        fp.write("<end node> %s\n" % self.end)
    def writetree(self, fp):
        self.writenode(fp)
        for node in self.children:
            node.writetree(fp)

class NodeReader:
    def __init__(self, fname, fp):
        self.fname    = fname
        self.fp       = fp
    def expect(self, text, line=None):
        if line is None:
            line = self.fp.readline().strip()
        assert line == text, "expected " + line + " == " + text
    def readstart(self):
        self.expect(VERSION)
    def readnode(self):
        line = self.fp.readline()
        if line is None:
            return None
        line = line.strip()
        if len(line) < 1:
            return None
        self.expect("dt=Text", line)
        self.expect("<node>")
        node = Node()
        node.title = self.fp.readline().strip()
        node.level = int(self.fp.readline().strip())
        while 1:
            line = self.fp.readline()
            m = re.match(END_RE, line)
            if m:
                node.end = m.group(1).strip()
                break
            node.article.append( line.strip() )
        return node

class TreeReader:
    def __init__(self, fname, fp=None):
        if fp is None: fp = open(fname, 'r')
        self.nodereader = NodeReader(fname, fp)
        self.root = None
        self.prev = None
    def add(self, node):
        if self.prev is None:
            assert node.level == 0
            self.root = node
        else:
            assert node.level > 0
            parent = self.prev.findparent(node)
            parent.addchild( node )
        self.prev = node
    def read(self):
        self.nodereader.readstart()
        prev = None
        while 1:
            node = self.nodereader.readnode()
            if node is None: break
            self.add(node)

class TreeWriter:
    def __init__(self, fname, fp=None):
        if fp is None: fp = open(fname, 'w')
        self.fname = fname
        self.fp    = fp
    def write(self, root):
        self.fp.write("%s\n" % VERSION)
        root.writetree(self.fp)

# Main
#
class Main:
    def __init__(self):
        self.infile  = sys.argv[1]
        self.outfile = sys.argv[2]
	self.reader  = TreeReader(self.infile)
        self.writer  = TreeWriter(self.outfile)
    def Run(self):
        self.reader.read()
        self.writer.write( self.reader.root )

if __name__ == '__main__':
    Main().Run()