import traceback

import xml.dom.minidom as minidom

sys.path.append(os.path.dirname(__file__)+"/../lib")

import opts

import Parser

import sql

import util

import xml_dom

import xml_func

def metadata_value(name):

    if type(name) == str and name.startswith(':'): return name[1:]

    else: return None

def main():

    env_names = []

    limit = opts.get_env_var('n', None, env_names)

    commit = opts.env_flag('commit')

    # Get db config from env vars

    db_config_names = ['engine', 'host', 'user', 'password', 'database']

    def get_db_config(prefix):

        return opts.get_env_vars(db_config_names, prefix, env_names)

    in_db_config = get_db_config('in')

    in_is_db = 'engine' in in_db_config

    map_path = None

    try: _prog_name, map_path = sys.argv

    except ValueError:

        if in_is_db: usage_err()

    # Load map header

    in_is_xpaths = True

    if map_path != None:

        import copy

        import xpath

        metadata = []

        mappings = []

        in_label, out_label = reader.next()[:2]

        def split_col_name(name):

            name, sep, root = name.partition(':')

        in_label, in_is_xpaths, in_root = split_col_name(in_label)

        assert out_is_xpaths # CSV output not supported yet

        has_types = out_root.startswith('/*s/') # outer elements are types

        for row in reader:

                if out_is_xpaths: out = out_root+out

        stream.close()

    in_is_xml = in_is_xpaths and not in_is_db

    if in_is_xml: doc0 = minidom.parse(sys.stdin)

    def process_input(use_row):

        doc1 = xml_dom.create_doc(out_label)

        root = doc1.documentElement

        def process_rows(get_value, rows):

            '''Processes input values

            for i, row in enumerate(rows):

                    if not (limit == None or i < limit): break

                except Exception: traceback.print_exc()

        if map_path == None:

        elif in_is_db:

            assert in_is_xpaths

            import db_xml

            in_root_xml = xpath.path2xml(in_root)

            for i, mapping in enumerate(mappings):

                    mappings[i] = (xpath.path2xml(in_root+'/'+in_), out)

            in_db = sql.connect(in_db_config)

            in_pkeys = {}

            def get_value(in_, row):

                pkey, = row

                in_ = in_.cloneNode(True) # don't modify orig value!

            process_rows(get_value, sql.rows(db_xml.get(in_db, in_root_xml,

            in_db.close()

        elif in_is_xml:

            def get_value(in_, row):

            process_rows(get_value, xml_dom.NodeElemIter(row0.parentNode))

        else: # input is CSV

            map_ = dict(mappings)

            reader = csv.reader(sys.stdin)

            cols = reader.next()

            col_idxs = dict([(value, idx) for idx, value in enumerate(cols)])

            for i, mapping in enumerate(mappings):

            def get_value(in_, row):

            process_rows(get_value, reader)

        xml_func.process(root)

        return doc1

    if out_is_db:

        from psycopg2.extensions import ISOLATION_LEVEL_SERIALIZABLE

        out_db = sql.connect(out_db_config)

        out_pkeys = {}

        try:

            def use_row(root):

                    db_xml.put(out_db, root, False, row_ct_ref, out_pkeys)

                    if commit: db.commit()

            map(use_row, process_input(use_row).firstChild)

            print 'Inserted '+str(row_ct_ref[0])+' rows'

            out_db.rollback()

    else: # output is XML

        config = xml_dom.prettyxml_config

        doc = xml_dom.create_doc(out_label)

        map(use_row, process_input(use_row).firstChild)

        doc.write_closing(output, **config)

try: main()

except Parser.SyntaxException, e: raise SystemExit(str(e))