#!/usr/bin/python

__version__ = "0.1"

import sys
try:
    import hachoir
except ImportError:
    import os
    sys.path.append(os.path.join(sys.path[0], '..'))
    import hachoir

from hachoir.error import error, HachoirError
from hachoir.cmd_line import (getHachoirOptions, getTerminalCharset,
    createParser, initHachoir)
from hachoir.metadata import extractMetadata
from hachoir.stream import InputStreamError
from optparse import OptionGroup, OptionParser

def displayVersion(*args):
    print "Metadata extractor version %s" % __version__
    print "Hachoir library version %s" % hachoir.__version__
    print
    print "Website: %s" % hachoir.website
    sys.exit(0)

def parseOptions():
    parser = OptionParser(usage="%prog [options] files")

    common = OptionGroup(parser, "Metadata", "Option of metadata extraction and display")
    common.add_option("--mime", help="Only display file MIME type",
        action="store_true", default=False)
    common.add_option("--level",
        help="Quantify of information to display (1 to 9, level 9 is all)",
        action="store", default="9", type="choice",
        choices=[ str(choice) for choice in xrange(1,9+1) ])
    common.add_option("--no-human", help="Display human display",
        action="store_true", default=False)
    common.add_option("--version", help="Display version and exit",
        action="callback", callback=displayVersion)
    parser.add_option_group(common)

    hachoir = getHachoirOptions(parser, console_ui=True)
    parser.add_option_group(hachoir)

    values, filename = parser.parse_args()
    if len(filename) == 0:
        parser.print_usage()
        sys.exit(1)
    return values, filename

def processFile(filename, charset, display_filename, priority, human, display=True):
    # Create parser

    try:
        parser = createParser(filename)
    except InputStreamError, err:
        error(str(err))
        return False
    if not parser:
        error("Unable to parse file: %s" % filename)
        return False

    # Extract metadata
    try:
        metadata = extractMetadata(parser)
    except HachoirError, err:
        error(str(err))
        metadata = None
    if not metadata:
        error("Unable to read metadata of file: %s" % filename)
        return False

    # Display metadatas on stdout
    text = metadata.exportPlaintext(priority, charset, human)
    if not text:
        text = "(no metadata, priority may be too small)"
    if display_filename:
        for line in text.split("\n"):
            print "%s: %s" % (filename, line)
    else:
        print text
    return True

def displayMime(filenames):
    exit_code = True
    for filename in filenames:
        ok = False
        try:
            parser = createParser(filename)
            if parser:
                msg = parser.mime_type
                ok = True
            else:
                msg = "No suitable parser"
        except InputStreamError, err:
            msg = "Open error: %s" % str(err)
        msg = "%s: %s\n" % (filename, msg)
        if ok:
            sys.stdout.write(msg)
        else:
            sys.stderr.write(msg)
            exit_code = False
    return exit_code

def main():
    values, filenames = parseOptions()
    initHachoir(values)
    if not values.mime:
        human = not(values.no_human)
        from hachoir.metadata.metadata import Data
        priority = int(values.level)*100 + 99
        display_filename = (1 < len(filenames))
        ok = True
        charset = getTerminalCharset()
        for filename in filenames:
            ok &= processFile(filename, charset, display_filename, priority, human)
    else:
        ok = displayMime(filenames)
    if ok:
        sys.exit(0)
    else:
        sys.exit(1)

if __name__ == "__main__":
    main()

