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