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