# XML-database conversion

import re

from xml.dom import Node

import sql

import strings

import util

import xml_dom

def name_of(node): return re.sub(r'^.*\.', r'', node.tagName)

ptr_suffix = '_id'

def is_ptr(node_name): return node_name.lower().endswith(ptr_suffix)

def ptr_type(node_name):

    assert is_ptr(node_name)

    return node_name[:-len(ptr_suffix)]

def ptr_target(node):

    assert is_ptr(name_of(node))

    return xml_dom.first_elem(node)

def find_by_name(node, name):

    for parent in xml_dom.NodeParentIter(node):

        if name_of(parent) == name: return parent

        else:

            for child in xml_dom.NodeElemIter(parent):

                child_name = name_of(child)

                if is_ptr(child_name):

                    if ptr_type(child_name) == name: return ptr_target(child)

                elif child_name == name: return child

    return None

def get(db, node, pkeys=None, limit=None):

    if pkeys == None: pkeys = {}

    def pkey(table): return sql.pkey(db, pkeys, table)

    node = node.firstChild

    table = name_of(node)

    pkey_ = pkey(table)

    fields = []

    conds = {}

    for child in xml_dom.NodeElemIter(node):

        child_name = name_of(child)

        if xml_dom.is_empty(child): fields.append(child_name)

        elif xml_dom.is_text(child): conds[child_name] = xml_dom.value(child)

        else: raise Exception('Joins not supported yet')

    id_ = xml_dom.get_id(node)

    if id_ != '': conds[pkey(table)] = id_ # replace any existing pkey value

    if fields == []: fields.append(pkey_)

    return sql.select(db, table, fields, conds, limit)

def put(db, node, store_ids=False, row_ct_ref=None, pkeys=None, parent_id=None):

    '''store_ids enables searching the tree for missing fields'''

    if pkeys == None: pkeys = {}

    def pkey(table): return sql.pkey(db, pkeys, table)

    table = name_of(node)

    pkey_ = pkey(table)

    row = {}

    children = []

    # Divide children into fields and children with fkeys to parent

    for child in xml_dom.NodeElemIter(node):

        child_name = name_of(child)

        if xml_dom.is_text(child):

            row[child_name] = strings.to_unicode(xml_dom.value(child))

        elif is_ptr(child_name): row[child_name] = put(db, ptr_target(child),

            store_ids, row_ct_ref, pkeys)

        else: children.append(child)

    try: del row[pkey_]

    except KeyError: pass

    # Add fkey to parent

    if parent_id != None:

        parent_ptr = node.getAttribute('fkey')

        if parent_ptr == '': parent_ptr = pkey(name_of(node.parentNode))

        row[parent_ptr] = parent_id

    # Insert node

    for try_num in xrange(2):

        try:

            id_ = sql.get(db, table, row, pkey_, True, row_ct_ref)

            if store_ids: xml_dom.set_id(node, id_)

            break

        except sql.NullValueException, ex:

            if try_num > 0: raise # exception still raised after retry

            if store_ids and is_ptr(ex.col):

                # Search for required column in ancestors and their children

                target = find_by_name(node, ptr_type(ex.col))

                if target == None: raise

                row[ex.col] = xml_dom.get_id(target)

            else: raise

    # Insert children with fkeys to parent

    for child in children: put(db, child, store_ids, row_ct_ref, pkeys, id_)

    return id_

def xml2db(db, node, row_ct_ref=None):

    iter_ = xml_dom.NodeElemIter(node)

    util.skip(iter_, xml_dom.is_text) # skip metadata

    for child in iter_: put(db, child, False, row_ct_ref)