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