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