#!/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

import os.path

import sys

import xml.dom.minidom

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

import opts

def main():

    # Get db config from env vars

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

    env_names = []

    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 = in_db_config != None

    out_is_db = out_db_config != None

    uses_map = in_is_db or not out_is_db

    # Parse args

    try: _prog_name, map_path = sys.argv

    except ValueError:

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

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

    commit = opts.env_flag('commit')

    # Load map header

    in_is_xml = True

    if uses_map:

        import copy

        import csv

        import xpath

        map_stream = open(map_path, 'rb')

        map_reader = csv.reader(map_stream)

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

        def split_col_name(name):

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

            return name, sep != '', root

        src, in_is_xml, src_root = split_col_name(src)

        dest, out_is_xml, dest_root = split_col_name(dest)

        assert out_is_xml

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

    # Input datasource to XML tree, mapping if needed

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

    if uses_map:

        from Parser import SyntaxException

        import xml_xpath

        map_ = {}

        for row in map_reader:

            in_, out = row[:2]

            if out != '':

                try: out = xpath.parse(dest_root+out)

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

                if in_is_xml: pass # TODO: process the mapping

                elif in_is_db: pass # TODO: process the mapping

                else: map_[in_] = out

        map_stream.close()

        out_doc = xml.dom.minidom.getDOMImplementation().createDocument(None,

            dest, None)

        if in_is_xml: raise Exception('XML-XML mapping not supported yet')

        else: # input is CSV

            reader = csv.reader(sys.stdin)

            fieldnames = reader.next()

            row_idx = 0

            for row in reader:

                row_id = str(row_idx)

                for idx, name in enumerate(fieldnames):

                    value = row[idx]

                    if value != '' and name in map_:

                        path = copy.deepcopy(map_[name]) # don't modify value!

                        xpath.set_id(path, row_id, has_types)

                        xpath.set_value(path, value)

                        xml_xpath.get(out_doc, path, True)

                row_idx += 1

        doc = out_doc

    # Output XML tree

    if out_db_config != None: # output is database

        import psycopg2

        from psycopg2.extensions import ISOLATION_LEVEL_SERIALIZABLE

        import db_xml

        db = psycopg2.connect(**out_db_config)

        db.set_isolation_level(ISOLATION_LEVEL_SERIALIZABLE)

        try:

            row_ct_ref = [0]

            db_xml.xml2db(db, doc.documentElement, row_ct_ref)

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

            if commit: db.commit()

        finally:

            db.rollback()

            db.close()

    else: doc.writexml(sys.stdout, addindent='    ', newl='\n') # output is XML

main()