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