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