#!/usr/bin/env python

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

# Exit status is the # of errors in the import, up to the maximum exit status

# 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 csv

import itertools

import os.path

import sys

import xml.dom.minidom as minidom

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

import csvs

import exc

import iters

import maps

import opts

import parallel

import Parser

import profiling

import sql

import streams

import strings

import term

import util

import xpath

import xml_dom

import xml_func

import xml_parse

def get_with_prefix(map_, prefixes, key):

    '''Gets all entries for the given key with any of the given prefixes'''

    values = []

    for key_ in strings.with_prefixes(['']+prefixes, key): # also with no prefix

        try: value = map_[key_]

        except KeyError, e: continue # keep going

        values.append(value)

    if values != []: return values

    else: raise e # re-raise last KeyError

def metadata_value(name): return None # this feature has been removed

def cleanup(val):

    if val == None: return val

    return util.none_if(strings.cleanup(strings.ustr(val)), u'', u'\\N')

def main_():

    env_names = []

    def usage_err():

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

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

    ## Get config from env vars

    # Modes

    test = opts.env_flag('test', False, env_names)

    commit = opts.env_flag('commit', False, env_names) and not test

        # never commit in test mode

    redo = opts.env_flag('redo', test, env_names) and not commit

        # never redo in commit mode (manually run `make empty_db` instead)

    # Ranges

    start = util.cast(int, opts.get_env_var('start', '0', env_names))

    if test: end_default = 1

    else: end_default = None

    end = util.cast(int, util.none_if(

        opts.get_env_var('n', end_default, env_names), u''))

    if end != None: end += start

    # Optimization

    if test: cpus_default = 0

    else: cpus_default = None

    cpus = util.cast(int, util.none_if(opts.get_env_var('cpus', cpus_default,

        env_names), u''))

    # Debugging

    debug = opts.env_flag('debug', False, env_names)

    sql.run_raw_query.debug = debug

    verbose = debug or opts.env_flag('verbose', not test, env_names)

    opts.get_env_var('profile_to', None, env_names) # add to env_names

    # DB

    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

    ##

    # Logging

    def log(msg, on=verbose):

        if on: sys.stderr.write(msg)

    def log_start(action, on=verbose): log(action+'...\n', on)

    # Parse args

    map_paths = sys.argv[1:]

    if map_paths == []:

        if in_is_db or not out_is_db: usage_err()

        else: map_paths = [None]

    def connect_db(db_config):

        log_start('Connecting to '+sql.db_config_str(db_config))

        return sql.connect(db_config)

    if end != None: end_str = str(end-1)

    else: end_str = 'end'

    log_start('Processing input rows '+str(start)+'-'+end_str)

    ex_tracker = exc.ExPercentTracker(iter_text='row')

    profiler = profiling.ItersProfiler(start_now=True, iter_text='row')

    # Parallel processing

    pool = parallel.MultiProducerPool(cpus)

    log_start('Using '+str(pool.process_ct)+' parallel CPUs')

    doc = xml_dom.create_doc()

    root = doc.documentElement

    out_is_xml_ref = [False]

    in_label_ref = [None]

    def update_in_label():

        if in_label_ref[0] != None:

            xpath.get(root, '/_ignore/inLabel="'+in_label_ref[0]+'"', True)

    def prep_root():

        root.clear()

        update_in_label()

    prep_root()

    def process_input(root, row_ready, map_path):

        '''Inputs datasource to XML tree, mapping if needed'''

        # Load map header

        in_is_xpaths = True

        out_is_xpaths = True

        out_label = None

        if map_path != None:

            metadata = []

            mappings = []

            stream = open(map_path, 'rb')

            reader = csv.reader(stream)

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

            def split_col_name(name):

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

                label, sep2, prefixes_str = label.partition('[')

                prefixes_str = strings.remove_suffix(']', prefixes_str)

                prefixes = strings.split(',', prefixes_str)

                return label, sep != '', root, prefixes

                    # extract datasrc from "datasrc[data_format]"

            in_label, in_root, prefixes = maps.col_info(in_label)

            in_is_xpaths = in_root != None

            in_label_ref[0] = in_label

            update_in_label()

            out_label, out_root = maps.col_info(out_label)[:2]

            out_is_xpaths = out_root != None

            if out_is_xpaths: has_types = out_root.find('/*s/') >= 0

                # outer elements are types

            for row in reader:

                in_, out = row[:2]

                if out != '':

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

                    mappings.append((in_, out))

            stream.close()

            root.ownerDocument.documentElement.tagName = out_label

        in_is_xml = in_is_xpaths and not in_is_db

        out_is_xml_ref[0] = out_is_xpaths and not out_is_db

        def process_rows(process_row, rows):

            '''Processes input rows

            @param process_row(in_row, i)

            '''

            i = 0

            while end == None or i < end:

                try: row = rows.next()

                except StopIteration: break # no more rows

                if i < start: continue # not at start row yet

                process_row(row, i)

                row_ready(i, row)

                i += 1

            row_ct = i-start

            return row_ct

        def map_rows(get_value, rows):

            '''Maps input rows

            @param get_value(in_, row):str

            '''

            def process_row(row, i):

                row_id = str(i)

                for in_, out in mappings:

                    value = metadata_value(in_)

                    if value == None:

                        log_start('Getting '+str(in_), debug)

                        value = cleanup(get_value(in_, row))

                    if value != None:

                        log_start('Putting '+str(out), debug)

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

            return process_rows(process_row, rows)

        def map_table(col_names, rows):

            col_names_ct = len(col_names)

            col_idxs = util.list_flip(col_names)

            i = 0

            while i < len(mappings): # mappings len changes in loop

                in_, out = mappings[i]

                if metadata_value(in_) == None:

                    try: mappings[i] = (

                        get_with_prefix(col_idxs, prefixes, in_), out)

                    except KeyError:

                        del mappings[i]

                        continue # keep i the same

                i += 1

            def get_value(in_, row):

                return util.coalesce(*util.list_subset(row.list, in_))

            def wrap_row(row):

                return util.ListDict(util.list_as_length(row, col_names_ct),

                    col_names, col_idxs) # handle CSV rows of different lengths

            return map_rows(get_value, util.WrapIter(wrap_row, rows))

        stdin = streams.LineCountStream(sys.stdin)

        def on_error(e):

            exc.add_msg(e, term.emph('input line #:')+' '+str(stdin.line_num))

            ex_tracker.track(e)

        if in_is_db:

            assert in_is_xpaths

            in_db = connect_db(in_db_config)

            cur = sql.select(in_db, table=in_root, fields=None, conds=None,

                limit=end, start=0)

            row_ct = map_table(list(sql.col_names(cur)), sql.rows(cur))

            in_db.db.close()

        elif in_is_xml:

            def get_rows(doc2rows):

                return iters.flatten(itertools.imap(doc2rows,

                    xml_parse.docs_iter(stdin, on_error)))

            if map_path == None:

                def doc2rows(in_xml_root):

                    iter_ = xml_dom.NodeElemIter(in_xml_root)

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

                    return iter_

                row_ct = process_rows(lambda row, i: root.appendChild(row),

                    get_rows(doc2rows))

            else:

                def doc2rows(in_xml_root):

                    rows = xpath.get(in_xml_root, in_root, limit=end)

                    if rows == []: raise SystemExit('Map error: Root "'

                        +in_root+'" not found in input')

                    return rows

                def get_value(in_, row):

                    in_ = './{'+(','.join(strings.with_prefixes(

                        ['']+prefixes, in_)))+'}' # also with no prefix

                    nodes = xpath.get(row, in_, allow_rooted=False)

                    if nodes != []: return xml_dom.value(nodes[0])

                    else: return None

                row_ct = map_rows(get_value, get_rows(doc2rows))

        else: # input is CSV

            map_ = dict(mappings)

            reader, col_names = csvs.reader_and_header(sys.stdin)

            row_ct = map_table(col_names, reader)

        return row_ct

    def process_inputs(root, row_ready):

        row_ct = 0

        for map_path in map_paths:

            row_ct += process_input(root, row_ready, map_path)

        return row_ct

    if out_is_db:

        import db_xml

        out_db = connect_db(out_db_config)

        try:

            if redo: sql.empty_db(out_db)

            row_ins_ct_ref = [0]

            def row_ready(row_num, input_row):

                def on_error(e):

                    exc.add_msg(e, term.emph('row #:')+' '+str(row_num))

                    exc.add_msg(e, term.emph('input row:')+'\n'+str(input_row))

                    exc.add_msg(e, term.emph('output row:')+'\n'+str(root))

                    ex_tracker.track(e, row_num)

                pool.share(on_error)

                xml_func.process(root, on_error)

                if not xml_dom.is_empty(root):

                    assert xml_dom.has_one_child(root)

                    try:

                        sql.with_savepoint(out_db,

                            lambda: db_xml.put(out_db, root.firstChild,

                                row_ins_ct_ref, on_error))

                        if commit: out_db.db.commit()

                    except sql.DatabaseErrors, e: on_error(e)

                prep_root()

            row_ct = process_inputs(root, row_ready)

            sys.stdout.write('Inserted '+str(row_ins_ct_ref[0])+

                ' new rows into database\n')

            # Consume asynchronous tasks

            pool.main_loop()

        finally:

            out_db.db.rollback()

            out_db.db.close()

    else:

        def on_error(e): ex_tracker.track(e)

        def row_ready(row_num, input_row): pass

        row_ct = process_inputs(root, row_ready)

        xml_func.process(root, on_error)

        if out_is_xml_ref[0]:

            doc.writexml(sys.stdout, **xml_dom.prettyxml_config)

        else: # output is CSV

            raise NotImplementedError('CSV output not supported yet')

    # Consume any asynchronous tasks not already consumed above

    pool.main_loop()

    profiler.stop(row_ct)

    ex_tracker.add_iters(row_ct)

    if verbose:

        sys.stderr.write('Processed '+str(row_ct)+' input rows\n')

        sys.stderr.write(profiler.msg()+'\n')

        sys.stderr.write(ex_tracker.msg()+'\n')

    ex_tracker.exit()

def main():

    try: main_()

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

if __name__ == '__main__':

    profile_to = opts.get_env_var('profile_to', None)

    if profile_to != None:

        import cProfile

        sys.stderr.write('Profiling to '+profile_to+'\n')

        cProfile.run(main.func_code, profile_to)

    else: main()