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