"""

gensuitemodule - Generate an AE suite module from an aete/aeut resource

Based on aete.py.

Reading and understanding this code is left as an exercise to the reader.

"""

from warnings import warnpy3k

warnpy3k("In 3.x, the gensuitemodule module is removed.", stacklevel=2)

import MacOS

import EasyDialogs

import os

import string

import sys

import types

import StringIO

import keyword

import macresource

import aetools

import distutils.sysconfig

import OSATerminology

from Carbon.Res import *

import Carbon.Folder

import MacOS

import getopt

import plistlib

_MAC_LIB_FOLDER=os.path.dirname(aetools.__file__)

DEFAULT_STANDARD_PACKAGEFOLDER=os.path.join(_MAC_LIB_FOLDER, 'lib-scriptpackages')

DEFAULT_USER_PACKAGEFOLDER=distutils.sysconfig.get_python_lib()

def usage():

    sys.stderr.write("Usage: %s [opts] application-or-resource-file\n" % sys.argv[0])

    sys.stderr.write("""Options:

--output pkgdir  Pathname of the output package (short: -o)

--resource       Parse resource file in stead of launching application (-r)

--base package   Use another base package in stead of default StdSuites (-b)

--edit old=new   Edit suite names, use empty new to skip a suite (-e)

--creator code   Set creator code for package (-c)

--dump           Dump aete resource to stdout in stead of creating module (-d)

--verbose        Tell us what happens (-v)

""")

    sys.exit(1)

def main():

    if len(sys.argv) > 1:

        SHORTOPTS = "rb:o:e:c:dv"

        LONGOPTS = ("resource", "base=", "output=", "edit=", "creator=", "dump", "verbose")

        try:

            opts, args = getopt.getopt(sys.argv[1:], SHORTOPTS, LONGOPTS)

        except getopt.GetoptError:

            usage()

        process_func = processfile

        basepkgname = 'StdSuites'

        output = None

        edit_modnames = []

        creatorsignature = None

        dump = None

        verbose = None

        for o, a in opts:

            if o in ('-r', '--resource'):

                process_func = processfile_fromresource

            if o in ('-b', '--base'):

                basepkgname = a

            if o in ('-o', '--output'):

                output = a

            if o in ('-e', '--edit'):

                split = a.split('=')

                if len(split) != 2:

                    usage()

                edit_modnames.append(split)

            if o in ('-c', '--creator'):

                if len(a) != 4:

                    sys.stderr.write("creator must be 4-char string\n")

                    sys.exit(1)

                creatorsignature = a

            if o in ('-d', '--dump'):

                dump = sys.stdout

            if o in ('-v', '--verbose'):

                verbose = sys.stderr

        if output and len(args) > 1:

            sys.stderr.write("%s: cannot specify --output with multiple inputs\n" % sys.argv[0])

            sys.exit(1)

        for filename in args:

            process_func(filename, output=output, basepkgname=basepkgname,

                edit_modnames=edit_modnames, creatorsignature=creatorsignature,

                dump=dump, verbose=verbose)

    else:

        main_interactive()

def main_interactive(interact=0, basepkgname='StdSuites'):

    if interact:

        # Ask for save-filename for each module

        edit_modnames = None

    else:

        # Use default filenames for each module

        edit_modnames = []

    appsfolder = Carbon.Folder.FSFindFolder(-32765, 'apps', 0)

    filename = EasyDialogs.AskFileForOpen(

        message='Select scriptable application',

        dialogOptionFlags=0x1056,       # allow selection of .app bundles

        defaultLocation=appsfolder)

    if not filename:

        return

    if not is_scriptable(filename):

        if EasyDialogs.AskYesNoCancel(

                "Warning: application does not seem scriptable",

                yes="Continue", default=2, no="") <= 0:

            return

    try:

        processfile(filename, edit_modnames=edit_modnames, basepkgname=basepkgname,

        verbose=sys.stderr)

    except MacOS.Error, arg:

        print "Error getting terminology:", arg

        print "Retry, manually parsing resources"

        processfile_fromresource(filename, edit_modnames=edit_modnames,

            basepkgname=basepkgname, verbose=sys.stderr)

def is_scriptable(application):

    """Return true if the application is scriptable"""

    if os.path.isdir(application):

        plistfile = os.path.join(application, 'Contents', 'Info.plist')

        if not os.path.exists(plistfile):

            return False

        plist = plistlib.Plist.fromFile(plistfile)

        return plist.get('NSAppleScriptEnabled', False)

    # If it is a file test for an aete/aeut resource.

    currf = CurResFile()

    try:

        refno = macresource.open_pathname(application)

    except MacOS.Error:

        return False

    UseResFile(refno)

    n_terminology = Count1Resources('aete') + Count1Resources('aeut') + \

        Count1Resources('scsz') + Count1Resources('osiz')

    CloseResFile(refno)

    UseResFile(currf)

    return n_terminology > 0

def processfile_fromresource(fullname, output=None, basepkgname=None,

        edit_modnames=None, creatorsignature=None, dump=None, verbose=None):

    """Process all resources in a single file"""

    if not is_scriptable(fullname) and verbose:

        print >>verbose, "Warning: app does not seem scriptable: %s" % fullname

    cur = CurResFile()

    if verbose:

        print >>verbose, "Processing", fullname

    rf = macresource.open_pathname(fullname)

    try:

        UseResFile(rf)

        resources = []

        for i in range(Count1Resources('aete')):

            res = Get1IndResource('aete', 1+i)

            resources.append(res)

        for i in range(Count1Resources('aeut')):

            res = Get1IndResource('aeut', 1+i)

            resources.append(res)

        if verbose:

            print >>verbose, "\nLISTING aete+aeut RESOURCES IN", repr(fullname)

        aetelist = []

        for res in resources:

            if verbose:

                print >>verbose, "decoding", res.GetResInfo(), "..."

            data = res.data

            aete = decode(data, verbose)

            aetelist.append((aete, res.GetResInfo()))

    finally:

        if rf <> cur:

            CloseResFile(rf)

            UseResFile(cur)

    # switch back (needed for dialogs in Python)

    UseResFile(cur)

    if dump:

        dumpaetelist(aetelist, dump)

    compileaetelist(aetelist, fullname, output=output,

        basepkgname=basepkgname, edit_modnames=edit_modnames,

        creatorsignature=creatorsignature, verbose=verbose)

def processfile(fullname, output=None, basepkgname=None,

        edit_modnames=None, creatorsignature=None, dump=None,

        verbose=None):

    """Ask an application for its terminology and process that"""

    if not is_scriptable(fullname) and verbose:

        print >>verbose, "Warning: app does not seem scriptable: %s" % fullname

    if verbose:

        print >>verbose, "\nASKING FOR aete DICTIONARY IN", repr(fullname)

    try:

        aedescobj, launched = OSATerminology.GetAppTerminology(fullname)

    except MacOS.Error, arg:

        if arg[0] in (-1701, -192): # errAEDescNotFound, resNotFound

            if verbose:

                print >>verbose, "GetAppTerminology failed with errAEDescNotFound/resNotFound, trying manually"

            aedata, sig = getappterminology(fullname, verbose=verbose)

            if not creatorsignature:

                creatorsignature = sig

        else:

            raise

    else:

        if launched:

            if verbose:

                print >>verbose, "Launched", fullname

        raw = aetools.unpack(aedescobj)

        if not raw:

            if verbose:

                print >>verbose, 'Unpack returned empty value:', raw

            return

        if not raw[0].data:

            if verbose:

                print >>verbose, 'Unpack returned value without data:', raw

            return

        aedata = raw[0]

    aete = decode(aedata.data, verbose)

    if dump:

        dumpaetelist([aete], dump)

        return

    compileaete(aete, None, fullname, output=output, basepkgname=basepkgname,

        creatorsignature=creatorsignature, edit_modnames=edit_modnames,

        verbose=verbose)

def getappterminology(fullname, verbose=None):

    """Get application terminology by sending an AppleEvent"""

    # First check that we actually can send AppleEvents

    if not MacOS.WMAvailable():

        raise RuntimeError, "Cannot send AppleEvents, no access to window manager"

    # Next, a workaround for a bug in MacOS 10.2: sending events will hang unless

    # you have created an event loop first.

    import Carbon.Evt

    Carbon.Evt.WaitNextEvent(0,0)

    if os.path.isdir(fullname):

        # Now get the signature of the application, hoping it is a bundle

        pkginfo = os.path.join(fullname, 'Contents', 'PkgInfo')

        if not os.path.exists(pkginfo):

            raise RuntimeError, "No PkgInfo file found"

        tp_cr = open(pkginfo, 'rb').read()

        cr = tp_cr[4:8]

    else:

        # Assume it is a file

        cr, tp = MacOS.GetCreatorAndType(fullname)

    # Let's talk to it and ask for its AETE

    talker = aetools.TalkTo(cr)

    try:

        talker._start()

    except (MacOS.Error, aetools.Error), arg:

        if verbose:

            print >>verbose, 'Warning: start() failed, continuing anyway:', arg

    reply = talker.send("ascr", "gdte")

    #reply2 = talker.send("ascr", "gdut")

    # Now pick the bits out of the return that we need.

    return reply[1]['----'], cr

def compileaetelist(aetelist, fullname, output=None, basepkgname=None,

            edit_modnames=None, creatorsignature=None, verbose=None):

    for aete, resinfo in aetelist:

        compileaete(aete, resinfo, fullname, output=output,

            basepkgname=basepkgname, edit_modnames=edit_modnames,

            creatorsignature=creatorsignature, verbose=verbose)

def dumpaetelist(aetelist, output):

    import pprint

    pprint.pprint(aetelist, output)

def decode(data, verbose=None):

    """Decode a resource into a python data structure"""

    f = StringIO.StringIO(data)

    aete = generic(getaete, f)

    aete = simplify(aete)

    processed = f.tell()

    unprocessed = len(f.read())

    total = f.tell()

    if unprocessed and verbose:

        verbose.write("%d processed + %d unprocessed = %d total\n" %

                         (processed, unprocessed, total))

    return aete

def simplify(item):

    """Recursively replace singleton tuples by their constituent item"""

    if type(item) is types.ListType:

        return map(simplify, item)

    elif type(item) == types.TupleType and len(item) == 2:

        return simplify(item[1])

    else:

        return item

# Here follows the aete resource decoder.

# It is presented bottom-up instead of top-down because there are  direct

# references to the lower-level part-decoders from the high-level part-decoders.

def getbyte(f, *args):

    c = f.read(1)

    if not c:

        raise EOFError, 'in getbyte' + str(args)

    return ord(c)

def getword(f, *args):

    getalign(f)

    s = f.read(2)

    if len(s) < 2:

        raise EOFError, 'in getword' + str(args)

    return (ord(s[0])<<8) | ord(s[1])

def getlong(f, *args):

    getalign(f)

    s = f.read(4)

    if len(s) < 4:

        raise EOFError, 'in getlong' + str(args)

    return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])

def getostype(f, *args):

    getalign(f)

    s = f.read(4)

    if len(s) < 4:

        raise EOFError, 'in getostype' + str(args)

    return s

def getpstr(f, *args):

    c = f.read(1)

    if len(c) < 1:

        raise EOFError, 'in getpstr[1]' + str(args)

    nbytes = ord(c)

    if nbytes == 0: return ''

    s = f.read(nbytes)

    if len(s) < nbytes:

        raise EOFError, 'in getpstr[2]' + str(args)

    return s

def getalign(f):

    if f.tell() & 1:

        c = f.read(1)

        ##if c <> '\0':

        ##  print align:', repr(c)

def getlist(f, description, getitem):

    count = getword(f)

    list = []

    for i in range(count):

        list.append(generic(getitem, f))

        getalign(f)

    return list

def alt_generic(what, f, *args):

    print "generic", repr(what), args

    res = vageneric(what, f, args)

    print '->', repr(res)

    return res

def generic(what, f, *args):

    if type(what) == types.FunctionType:

        return apply(what, (f,) + args)

    if type(what) == types.ListType:

        record = []

        for thing in what:

            item = apply(generic, thing[:1] + (f,) + thing[1:])

            record.append((thing[1], item))

        return record

    return "BAD GENERIC ARGS: %r" % (what,)

getdata = [

    (getostype, "type"),

    (getpstr, "description"),

    (getword, "flags")

    ]

getargument = [

    (getpstr, "name"),

    (getostype, "keyword"),

    (getdata, "what")

    ]

getevent = [

    (getpstr, "name"),

    (getpstr, "description"),

    (getostype, "suite code"),

    (getostype, "event code"),

    (getdata, "returns"),

    (getdata, "accepts"),

    (getlist, "optional arguments", getargument)

    ]

getproperty = [

    (getpstr, "name"),

    (getostype, "code"),

    (getdata, "what")

    ]

getelement = [

    (getostype, "type"),

    (getlist, "keyform", getostype)

    ]

getclass = [

    (getpstr, "name"),

    (getostype, "class code"),

    (getpstr, "description"),

    (getlist, "properties", getproperty),

    (getlist, "elements", getelement)

    ]

getcomparison = [

    (getpstr, "operator name"),

    (getostype, "operator ID"),

    (getpstr, "operator comment"),

    ]

getenumerator = [

    (getpstr, "enumerator name"),

    (getostype, "enumerator ID"),

    (getpstr, "enumerator comment")

    ]

getenumeration = [

    (getostype, "enumeration ID"),

    (getlist, "enumerator", getenumerator)

    ]

getsuite = [

    (getpstr, "suite name"),

    (getpstr, "suite description"),

    (getostype, "suite ID"),

    (getword, "suite level"),

    (getword, "suite version"),

    (getlist, "events", getevent),

    (getlist, "classes", getclass),

    (getlist, "comparisons", getcomparison),

    (getlist, "enumerations", getenumeration)

    ]

getaete = [

    (getword, "major/minor version in BCD"),

    (getword, "language code"),

    (getword, "script code"),

    (getlist, "suites", getsuite)

    ]

def compileaete(aete, resinfo, fname, output=None, basepkgname=None,

        edit_modnames=None, creatorsignature=None, verbose=None):

    """Generate code for a full aete resource. fname passed for doc purposes"""

    [version, language, script, suites] = aete

    major, minor = divmod(version, 256)

    if not creatorsignature:

        creatorsignature, dummy = MacOS.GetCreatorAndType(fname)

    packagename = identify(os.path.splitext(os.path.basename(fname))[0])

    if language:

        packagename = packagename+'_lang%d'%language

    if script:

        packagename = packagename+'_script%d'%script

    if len(packagename) > 27:

        packagename = packagename[:27]

    if output:

        # XXXX Put this in site-packages if it isn't a full pathname?

        if not os.path.exists(output):

            os.mkdir(output)

        pathname = output

    else:

        pathname = EasyDialogs.AskFolder(message='Create and select package folder for %s'%packagename,

            defaultLocation=DEFAULT_USER_PACKAGEFOLDER)

        output = pathname

    if not pathname:

        return

    packagename = os.path.split(os.path.normpath(pathname))[1]

    if not basepkgname:

        basepkgname = EasyDialogs.AskFolder(message='Package folder for base suite (usually StdSuites)',

            defaultLocation=DEFAULT_STANDARD_PACKAGEFOLDER)

    if basepkgname:

        dirname, basepkgname = os.path.split(os.path.normpath(basepkgname))

        if dirname and not dirname in sys.path:

            sys.path.insert(0, dirname)

        basepackage = __import__(basepkgname)

    else:

        basepackage = None

    suitelist = []

    allprecompinfo = []

    allsuites = []

    for suite in suites:

        compiler = SuiteCompiler(suite, basepackage, output, edit_modnames, verbose)

        code, modname, precompinfo = compiler.precompilesuite()

        if not code:

            continue

        allprecompinfo = allprecompinfo + precompinfo

        suiteinfo = suite, pathname, modname

        suitelist.append((code, modname))

        allsuites.append(compiler)

    for compiler in allsuites:

        compiler.compilesuite(major, minor, language, script, fname, allprecompinfo)

    initfilename = os.path.join(output, '__init__.py')

    fp = open(initfilename, 'w')

    MacOS.SetCreatorAndType(initfilename, 'Pyth', 'TEXT')

    fp.write('"""\n')

    fp.write("Package generated from %s\n"%ascii(fname))

    if resinfo:

        fp.write("Resource %s resid %d %s\n"%(ascii(resinfo[1]), resinfo[0], ascii(resinfo[2])))

    fp.write('"""\n')

    fp.write('import aetools\n')

    fp.write('Error = aetools.Error\n')

    suitelist.sort()

    for code, modname in suitelist:

        fp.write("import %s\n" % modname)

    fp.write("\n\n_code_to_module = {\n")

    for code, modname in suitelist:

        fp.write("    '%s' : %s,\n"%(ascii(code), modname))

    fp.write("}\n\n")

    fp.write("\n\n_code_to_fullname = {\n")

    for code, modname in suitelist:

        fp.write("    '%s' : ('%s.%s', '%s'),\n"%(ascii(code), packagename, modname, modname))

    fp.write("}\n\n")

    for code, modname in suitelist:

        fp.write("from %s import *\n"%modname)

    # Generate property dicts and element dicts for all types declared in this module

    fp.write("\ndef getbaseclasses(v):\n")

    fp.write("    if not getattr(v, '_propdict', None):\n")

    fp.write("        v._propdict = {}\n")

    fp.write("        v._elemdict = {}\n")

    fp.write("        for superclassname in getattr(v, '_superclassnames', []):\n")

    fp.write("            superclass = eval(superclassname)\n")

    fp.write("            getbaseclasses(superclass)\n")

    fp.write("            v._propdict.update(getattr(superclass, '_propdict', {}))\n")

    fp.write("            v._elemdict.update(getattr(superclass, '_elemdict', {}))\n")

    fp.write("        v._propdict.update(getattr(v, '_privpropdict', {}))\n")

    fp.write("        v._elemdict.update(getattr(v, '_privelemdict', {}))\n")

    fp.write("\n")

    fp.write("import StdSuites\n")

    allprecompinfo.sort()

    if allprecompinfo:

        fp.write("\n#\n# Set property and element dictionaries now that all classes have been defined\n#\n")

        for codenamemapper in allprecompinfo:

            for k, v in codenamemapper.getall('class'):

                fp.write("getbaseclasses(%s)\n" % v)

    # Generate a code-to-name mapper for all of the types (classes) declared in this module