#!/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 0.4.9\n" \
              "Copyright (c) 2010 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
