#!/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 1.0.2\n" \
              "Copyright (c) 2013 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
