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