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