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