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