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