#!/usr/bin/env python3

# compressor.py
from subprocess import Popen, PIPE

def compress(value):
    """Compresses a byte array with the xz binary"""

    process = Popen(["xz", "--compress", "--force"], stdin=PIPE, stdout=PIPE)
    return process.communicate(value)[0]

def decompress(value):
    """Decompresses a byte array with the xz binary"""

    process = Popen(["xz", "--decompress", "--stdout", "--force"],
                    stdin=PIPE, stdout=PIPE)
    return process.communicate(value)[0]

def compress_file(path):
    """Compress the file at 'path' with the xz binary"""

    process = Popen(["xz", "--compress", "--force", "--stdout", path], stdout=PIPE)
    return process.communicate()[0]

# compressor.py

import os
import sys
from optparse import OptionParser
from sys import argv
import base64
try:
    import cPickle as pickle
except ImportError:
    import pickle
from io import BytesIO

from os.path import basename
from errno import EPIPE

def load():
    ppds_compressed = base64.b64decode(ppds_compressed_b64)
    ppds_decompressed = decompress(ppds_compressed)
    ppds = pickle.loads(ppds_decompressed)
    return ppds

def ls():
    binary_name = basename(argv[0])
    ppds = load()
    for key, value in ppds.items():
        if key == 'ARCHIVE': continue
        for ppd in value[2]:
            try:
                print(ppd.replace('"', '"' + binary_name + ':', 1))
            except IOError as e:
                # Errors like broken pipes (program which takes the standard
                # output terminates before this program terminates) should not
                # generate a traceback.
                if e.errno == EPIPE: exit(0)
                raise

def cat(ppd):
    # Ignore driver's name, take only PPD's
    ppd = ppd.split(":")[-1]
    # Remove also the index
    ppd = "0/" + ppd[ppd.find("/")+1:]

    ppds = load()
    ppds['ARCHIVE'] = BytesIO(decompress(ppds['ARCHIVE']))

    if ppd in ppds:
        start = ppds[ppd][0]
        length = ppds[ppd][1]
        ppds['ARCHIVE'].seek(start)
        return ppds['ARCHIVE'].read(length)

def main():
    usage = "usage: %prog list\n" \
            "       %prog cat URI"
    version = "%prog 1.0.2\n" \
              "Copyright (c) 2013 Vitor Baptista.\n" \
              "This is free software; see the source for copying conditions.\n" \
              "There is NO warranty; not even for MERCHANTABILITY or\n" \
              "FITNESS FOR A PARTICULAR PURPOSE."
    parser = OptionParser(usage=usage,
                          version=version)
    (options, args) = parser.parse_args()

    if len(args) == 0 or len(args) > 2:
        parser.error("incorrect number of arguments")

    if args[0].lower() == 'list':
        ls()
    elif args[0].lower() == 'cat':
        if not len(args) == 2:
            parser.error("incorrect number of arguments")
        ppd = cat(args[1])
        if not ppd:
            parser.error("Printer '%s' does not have default driver!" % args[1])
        try:
            # avoid any assumption of encoding or system locale; just print the
            # bytes of the PPD as they are
            if sys.version_info.major < 3:
                sys.stdout.write(ppd)
            else:
                sys.stdout.buffer.write(ppd)
        except IOError as e:
            # Errors like broken pipes (program which takes the standard output
            # terminates before this program terminates) should not generate a
            # traceback.
            if e.errno == EPIPE: exit(0)
            raise
    else:
        parser.error("argument " + args[0] + " invalid")

# PPDs Archive
ppds_compressed_b64 = b"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"

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        # We don't want a KeyboardInterrupt throwing a
        # traceback into stdout.
        pass
