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