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

import csv

import os

import os.path

import re

import sys

import xml.dom.minidom

from xml.dom.minidom import getDOMImplementation

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

def env_flag(name): return name in os.environ and os.environ[name] != ''

def main():

    # Get db config from env vars

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

    env_names = []

    def get_db_config(prefix):

        has_all = True

        db_config = {}

        for name in db_config_names:

            env_name = prefix+'_'+name

            env_names.append(env_name)

            if env_name in os.environ: db_config[name] = os.environ[env_name]

            else: has_all = False

        if has_all: return db_config

        else: return None

    from_db_config = get_db_config('from')

    to_db_config = get_db_config('to')

    uses_map = not (from_db_config == None and to_db_config != None)

    # Parse args

    prog_name = sys.argv[0]

    try: prog_name, map_path = sys.argv

    except ValueError:

        if uses_map: raise SystemExit('Usage: env'+''.join(map(lambda name:

            ' ['+name+'=...]', env_names))+' [commit=1] '+prog_name

            +' [map_path] [<input] [>output]')

    commit = env_flag('commit')

    csv_config = dict(delimiter=',', quotechar='"')

    # Input datasource to XML tree

    if uses_map: # input is CSV

        import xpath

        # Load map

        map_ = {}

        has_types = False # whether outer elements are type containiners

        stream = open(map_path, 'rb')

        reader = csv.reader(stream, **csv_config)

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

        for row in reader:

            name, path = row[:2]

            if name != '' and path != '':

                if path.startswith('/*s/'): has_types = True # *s for type elem

                path = path.replace('<name>', name)

                map_[name] = xpath.XpathParser(path).parse()

        stream.close()

        # Load and map CSV

        doc = getDOMImplementation().createDocument(None, dest, None)

        reader = csv.reader(sys.stdin, **csv_config)

        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 main value!

                    xpath.set_id(path, row_id, has_types)

                    xpath.set_value(path, value)

                    xpath.get(doc, path, True)

            row_idx += 1

    else: doc = xml.dom.minidom.parse(sys.stdin) # input is XML

    # Output XML tree

    if to_db_config != None: # output is database

        import psycopg2

        from psycopg2.extensions import ISOLATION_LEVEL_SERIALIZABLE

        import db_xml

        db = psycopg2.connect(**to_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()