#!/usr/bin/env python2

from __future__ import unicode_literals

import argparse
import codecs
import csv
import os
import pkg_resources
import shelve
import sys

import nltk.tree as T

# TODO: document in user manual

def hash_file(args):
    filename = args.filename[0]
    print "Computing hash for %s." % filename
    contents = codecs.open(filename, "r", "utf-8").read()
    trees = contents.split("\n\n")
    vc = trees[0]
    if T.Tree(vc)[0].node != "VERSION":
        print "This file has no version cookie; adding."
        vc = "( (VERSION (HASH (MD5 none))))"
    else:
        trees = trees[1:]
        if annotald.util.queryVersionCookie(vc, "HASH.MD5"):
            print "Old hash present; overwriting."
        else:
            print "Adding hash to pre-existing version cookie."
    new_hash = annotald.util.hashTrees("\n\n".join(trees), vc)
    vc = annotald.util.updateVersionCookie(vc, "HASH.MD5", new_hash)
    annotald.util.writeTreesToFile(vc, "\n\n".join(trees), filename)
    print "Hash successfully updated."

def convert_file(args):
    filename = args.filename[0]
    with codecs.open(filename, "r", "utf-8") as f:
        trees = f.read()
    if args.cs:
        trees = annotald.util.scrubText(trees)
    annotald.util.writeTreesToFile(None, trees, filename)

def rewrite_indices(args):
    filename = args.filename[0]
    metadata = None
    with codecs.open(filename, "r", "utf-8") as f:
        trees = f.read().split("\n\n")
    trees = map(T.Tree, trees)
    if trees[0][0].node == "VERSION":
        metadata = trees[0]
        trees = trees[1:]
    trees = map(annotald.util.rewriteIndices, trees)
    annotald.util.writeTreesToFile(metadata, trees, filename)

def check_trees(args):
    filename = args.filename[0]
    with codecs.open(filename, "r", "utf-8") as f:
        trees = f.read().split("\n\n")
    for t in xrange(len(trees)):
        try:
            T.Tree(trees[t])
        except ValueError:
            print "Anomalous tree: %dth in the file, text is %s" % (t, trees[t])
    print "All trees checked"

def log_to_csv(args):
    if not os.path.exists("annotaldLog.shelve"):
        print "No annotaldLog.shelve in working directory."
        sys.exit(1)
    log = shelve.open("annotaldLog.shelve")
    rfile_real = open("annotaldLog.csv", "w")
    rfile = csv.writer(rfile_real)
    keys = set()
    for v in log.values():
        for k in v.keys():
            keys.add(k)
    keys = list(keys)
    keys.sort()

    times = log.keys()
    times.sort()
    rfile.writerow(["time"] + keys)
    for t in times:
        row = []
        row.append(t)
        for k in keys:
            try:
                row.append(log[t][k])
            except KeyError:
                row.append("NA")
        rfile.writerow(row)

    rfile_real.close()
    print "Annotald log converted to CSV successfully."

def cat_file(fname):
    with open(pkg_resources.resource_filename("annotald", fname)) as f:
        sys.stdout.write(f.read())

cat_settings_js = lambda args: cat_file("settings.js")
cat_settings_py = lambda args: cat_file("settings.py")

def reindent(args):
    fil = args.file_name[0]
    with codecs.open(fil, 'r', 'utf-8') as f:
        trees = f.read()
        annotald.util.writeTreesToFile(None, trees, fil, reformat = True,
                                       fix_indices = True)

def parse_args(args):
    parser = argparse.ArgumentParser(description = "A helper script for various Annotald functions")
    parser.add_argument("-d", "--dev", dest = "dev", action = "store_true",
                        help = "Only for developer use")
    subparsers = parser.add_subparsers()

    # hash-file
    hash_file_parser = subparsers.add_parser("hash-file",
                                             help = "add hash to a parsed file")
    hash_file_parser.add_argument("filename", nargs = 1)
    hash_file_parser.set_defaults(func = hash_file)

    # convert
    convert_parser = subparsers.add_parser("convert",
                                           help = "convert from another format algorithm")
    convert_parser.add_argument("-o", "--cs-output", dest = "cs",
                                action = "store_true",
                                help = "strip CorpusSearch comments")
    convert_parser.add_argument("filename", nargs = 1)
    convert_parser.set_defaults(func = convert_file)

    # rewrite-indices
    rewrite_parser = subparsers.add_parser('rewrite-indices',
                                          help = "rewrite tree indices in sequential order")
    rewrite_parser.add_argument("filename", nargs = 1)
    rewrite_parser.set_defaults(func = rewrite_indices)

    # check-trees
    check_parser = subparsers.add_parser('check-trees',
                                         help = "check that all trees are properly formatted")
    check_parser.add_argument("filename", nargs = 1)
    check_parser.set_defaults(func = check_trees)

    # csv-log
    csv_parser = subparsers.add_parser('csv-log',
                                         help = "convert log to CSV format")
    csv_parser.set_defaults(func = log_to_csv)

    # cat-settings-js
    psjs_parser = subparsers.add_parser('cat-settings-js',
                                        help = "print out default settings.js file")
    psjs_parser.set_defaults(func = cat_settings_js)

    # cat-settings-js
    pspy_parser = subparsers.add_parser('cat-settings-py',
                                        help = "print out default settings.py file")
    pspy_parser.set_defaults(func = cat_settings_py)

    # reindent
    reindent_parser = subparsers.add_parser('reindent',
                                            help = "reindent a .psd file")
    reindent_parser.add_argument("file_name", nargs = 1)
    reindent_parser.set_defaults(func = reindent)

    args = parser.parse_args(args)
    return args

if __name__ == "__main__":
    args = parse_args(sys.argv[1:])
    if args.dev:
        print "dev active"
        sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)) + "/..")
    import annotald.util

    args.func(args)

# Local Variables:
# mode: python
# End:
