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