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