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