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