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