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