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