#!/usr/bin/env python

# Maps one datasource to another, using a map spreadsheet if needed

# For outputting an XML file to a PostgreSQL database, use the general format of

# http://vegbank.org/vegdocs/xml/vegbank_example_ver1.0.2.xml

import os.path

import sys

import xml.dom.minidom

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

import opts

from Parser import SyntaxException

import sql

import xml_dom

import xml_func

def metadata_value(name):

    if name.startswith(':'): return name[1:]

    else: return None

def main():

    env_names = []

    def usage_err():

        raise SystemExit('Usage: '+opts.env_usage(env_names, True)

            +' [commit=1] '+sys.argv[0]+' [map_path] [<input] [>output]')

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

    if limit != None: limit = int(limit)

    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')

    out_db_config = get_db_config('out')

    in_is_db = 'engine' in in_db_config

    out_is_db = 'engine' in out_db_config

    # Parse args

    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 csv

        import xpath

        metadata = []

        mappings = []

        stream = open(map_path, 'rb')

        reader = csv.reader(stream)

        src, dest = reader.next()[:2]

        def split_col_name(name):

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

            return name, sep != '', root

        src, in_is_xpaths, src_root = split_col_name(src)

        dest, out_is_xpaths, dest_root = split_col_name(dest)

        assert out_is_xpaths # CSV output not supported yet

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

        for row in reader:

            in_, out = row[:2]

            if out != '':

                value = metadata_value(in_)

                is_metadata = value != None

                if in_is_xpaths and not is_metadata:

                    in_ = xpath.parse(src_root+in_)

                if out_is_xpaths: out = xpath.parse(dest_root+out)

                if is_metadata: metadata.append((value, out))

                else: mappings.append((in_, out))

        stream.close()

    in_is_xml = in_is_xpaths and not in_is_db

    # Input datasource to XML tree, mapping if needed

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

    if map_path != None:

        doc1 = xml_dom.create_doc(dest)

        root = doc1.documentElement

        if in_is_db:

            assert in_is_xpaths

            import db_xml

            src_root = xpath.parse(src_root)

            src_root_xml = xpath.path2xml(src_root)

            mappings = [(xpath.path2xml(in_), out) for in_, out in mappings]

            in_db = sql.connect(in_db_config)

            in_pkeys = {}

            for row_idx, row in enumerate(sql.rows(db_xml.get(in_db,

                src_root_xml, in_pkeys, limit))):

                row_id, = row

                row_id = str(row_id)

                def put_col(path, value):

                    xpath.put_obj(root, path, row_id, has_types, value)

                for value, out in metadata: put_col(out, value)

                for in_, out in mappings:

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

                    xml_dom.set_id(xpath.get(in_, src_root), row_id)

                    value = sql.value_or_none(db_xml.get(in_db, in_, in_pkeys))

                    if value != None: put_col(out, str(value))

            in_db.close()

        elif in_is_xml: raise SystemExit('XML input not supported yet')

        else: # input is CSV

            map_ = dict(mappings)

            reader = csv.reader(sys.stdin)

            cols = reader.next()

            for row_idx, row in enumerate(reader):

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

                row_id = str(row_idx)

                def put_col(path, value):

                    xpath.put_obj(root, path, row_id, has_types, value)

                for value, out in metadata: put_col(out, value)

                for i, col in enumerate(cols):

                    if row[i] != '' and col in map_: put_col(map_[col], row[i])

        xml_func.process(root)

    else: doc1 = doc0

    # Output XML tree

    if out_is_db:

        from psycopg2.extensions import ISOLATION_LEVEL_SERIALIZABLE

        import db_xml

        out_db = sql.connect(out_db_config)

        out_db.set_isolation_level(ISOLATION_LEVEL_SERIALIZABLE)

        try:

            row_ct_ref = [0]

            db_xml.xml2db(out_db, doc1.documentElement, row_ct_ref)

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

            if commit: out_db.commit()

        finally:

            out_db.rollback()

            out_db.close()

    else: xml_dom.writexml(sys.stdout, doc1) # output is XML

try: main()

except SyntaxException, ex: raise SystemExit(str(ex))