#!/usr/bin/env python

# ---
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
# ---

import os
import re
import sys
import json
import optparse

# see:
#    http://www.sitepen.com/blog/2009/06/23/unobtrusive-javascript-typing-via-json-schema-interfaces/
# for some info on JSON Schema for interfaces

#--------------------------------------------------------------------
def main():

    # parse args
    parser = optparse.OptionParser()
    parser.add_option("--validate",  action="store_true",                 help="validate types")
    parser.add_option("--anyType",   action="append",     metavar="TYPE", help="treat TYPE as an any")
    (options, args) = parser.parse_args()

    if options.anyType:
        AnyTypes.extend(options.anyType)

    if len(args) <= 0: error("no input files specified")
    iFileName = args[0]

    if len(args) <= 1:
        oFileName = "<stdout>"
    else:
        oFileName = args[1]

    # read input
    iFile = file(iFileName)
    content = iFile.read()
    iFile.close()

    # convert to JSONable
    module = parseIDL(content)

    splitNotifyInterfaces(module)

#    if module["name"] == "core":
#        if len(module["interfaces"]) == 1:
#            if module["interfaces"][0]["name"] == "Inspector":
#                splitInspectorInterfaces(module)

    # convert out parms to callback parms
    convertOutParms(module)

    # validate
    if options.validate: validate(module)

    # convert to JSON
    jsonModule = json.dumps(module, indent=3)

    # write output
    if oFileName == "<stdout>":
        oFile = sys.stdout
    else:
        oFile = file(oFileName,"w")

    oFile.write(jsonModule)

    # close file
    if oFileName != "<stdout>":
        oFile.close()
        log("generated json file '%s'" %oFileName)

#--------------------------------------------------------------------
def convertOutParms(module):
    for interface in module["interfaces"]:

        if "methods" in interface:
            for method in interface["methods"]:
                method["callbackParameters"] = []
                newParameters = []

                for parameter in method["parameters"]:
                    if "out" in parameter:
                        method["callbackParameters"].append(parameter)
                    else:
                        newParameters.append(parameter)

                method["parameters"] = newParameters

#--------------------------------------------------------------------
def splitNotifyInterfaces(module):
    newInterfaces = {}

    for interface in module["interfaces"][:]:

        if "methods" in interface:
            for method in interface["methods"][:]:
                if "extendedAttributes" not in method: continue
                if "notify" not in method["extendedAttributes"]: continue

                newInterfaceName = interface["name"] + "Notify"
                newInterface     = newInterfaces.get(newInterfaceName)

                if not newInterface:
                    newInterface = {
                        "name": newInterfaceName,
                        "methods": []
                    }
                    newInterfaces[newInterfaceName] = newInterface
                    module["interfaces"].append(newInterface)

                for parameter in method["parameters"]:
                    if "out" not in parameter:
                        log("%s notify method %s has an unexpected non-out parameter %s" % (interface["name"], method["name"], parameter["name"]))
                    else:
                        del parameter["out"]

                newInterface["methods"].append(method)
                interface["methods"].remove(method)

#--------------------------------------------------------------------
def splitInspectorInterfaces(module):
    intfOrig      = module["interfaces"][0]
    newInterfaces = {}

    module["interfaces"] = []

    for method in intfOrig["methods"]:
        if "domain" not in method["extendedAttributes"]:
            log("Inspector method %s does not have a 'domain' extended attribute" % (method["name"]))
            continue

        intfName = method["extendedAttributes"]["domain"]

        if "notify" in method["extendedAttributes"]:
            intfName += "Notify"

            for parameter in method["parameters"]:
                if "out" not in parameter:
                    log("Inspector method %s has an unexpected non-out parameter %s" % (method["name"], parameter["name"]))
                else:
                    del parameter["out"]

        intf = newInterfaces.get(intfName)
        if not intf:
            intf = {
                "name": intfName,
                "methods": []
            }
            newInterfaces[intfName] = intf
            module["interfaces"].append(intf)

        intf["methods"].append(method)

#        for parameter in method["parameters"]:
#            if "out" not in parameter:
#                log("Inspector method %s has an unexpected non-out parameter %s" % (method["name"], parameter["name"]))
#            else:
#                del parameter["out"]

#        intfWebInspector["methods"].append(method)

#--------------------------------------------------------------------
def validate(module):
    interfaces = {}

    errors = False

    # build table of interface names
    for interface in module["interfaces"]:
        interfaces[interface["name"]] = interface

    # check interfaces
    for interface in module["interfaces"]:

        if "methods" in interface:
            for method in interface["methods"]:
                location = "%s.%s" % (interface["name"], method["name"])
                errors = checkType(location, interfaces, method["returns"]) or errors

                for parameter in method["parameters"]:
                    errors = checkType(location, interfaces, parameter["type"]) or errors


        if "attributes" in interface:
            for attribute in interface["attributes"]:
                location = "%s.%s" % (interface["name"], attribute["name"])
                errors = checkType(location, interfaces, attribute["type"]) or errors


#--------------------------------------------------------------------
def checkType(location, interfaces, type):
    typeName = type["name"]

    if typeName in BuiltInTypes: return False
    if typeName in interfaces: return False

    log("type '%s' is not valid in %s" % (typeName, location))

    return True


#--------------------------------------------------------------------
def parseIDL(content):

    content = clean(content)

    match = PatternModule.match(content)
    if not match: error("no module found in input")

    moduleName = match.group(1).strip()
    content    = match.group(2)

    module = {}
    module["name"] = moduleName

    interfaces = []
    module["interfaces"] = interfaces

    while True:
        match = PatternInterface.match(content)
        if not match: break

        interfaceEAs  = match.group(1)
        interfaceName = match.group(2).strip()
        interfaceBody = match.group(3)
        content       = match.group(4)

        interface = {}
        interface["name"] = interfaceName
        parseExtendedAttributes(interface, interfaceEAs)

        interfaces.append(interface)

        while True:
            match = PatternMethod.match(interfaceBody)
            if match:
                method = parseMethod(match)
                if not "methods" in interface: interface["methods"] = []
                interface["methods"].append(method)

                interfaceBody = match.group(6)
                continue

            match = PatternAttribute.match(interfaceBody)
            if match:
                attribute = parseAttribute(match)
                if not "attributes" in interface: interface["attributes"] = []
                interface["attributes"].append(attribute)

                interfaceBody = match.group(5)
                continue

            if interfaceBody.strip() != "":
                error("unexpected input: '%s'" % interfaceBody)

            break

    if content.strip() != "}": error("unexpected input: '%s'" % content)

    return module

#--------------------------------------------------------------------
def parseExtendedAttributes(object, eaStrings):
    if not eaStrings: return
    if eaStrings == "": return

    eaStrings = eaStrings[1:-1]
    eaStrings = eaStrings.split(",")

    eas = {}
    for eaString in eaStrings:
        match = PatternExtendedAttribute.match(eaString)
        if not match:
            error("invalid extended attribute: '%s'" % eaString)

        if match.group(3):
            eas[match.group(1)] = match.group(3)
        else:
            eas[match.group(1)] = True

    if len(eas):
        object["extendedAttributes"] = eas

#--------------------------------------------------------------------
def parseMethod(match):
    method = {}

    eas                  = match.group(1)
    method["returns"]    = getType(match.group(2), match.group(3))
    method["name"]       = match.group(4)
    method["parameters"] = parseMethodParameters(match.group(5))

    parseExtendedAttributes(method, eas)

    return method

#--------------------------------------------------------------------
def parseAttribute(match):
    attribute = {}

    eas               = match.group(1)
    attribute["type"] = getType(match.group(2), match.group(3))
    attribute["name"] = match.group(4)

    parseExtendedAttributes(attribute, eas)

    return attribute

#--------------------------------------------------------------------
def parseMethodParameters(parameterString):
    parameters = []

    parameterString = parameterString.strip()
    if "" == parameterString: return parameters

    parmStrings = parameterString.split(",")
    for parmString in parmStrings:
        parameter = {}

        parts = parmString.split()
        if parts[0] in ["in", "out"]:
            parmString = " ".join(parts[1:])
            if parts[0] == "out":
                parameter["out"] = True

        match = PatternParameter.match(parmString)
        if not match:
            error("error parsing parameter in '" + parameterString + "'")


        parameter["type"] = getType(match.group(1), match.group(2))

        if match.group(5):
            parameter["name"] = match.group(5)
        else:
            parameter["name"] = match.group(3)

        parameters.append(parameter)

    return parameters

#--------------------------------------------------------------------
def getType(name, rank):
    name = name.strip()
    rank = PatternWhiteSpace.sub("", rank)

    origName = name

    if name == "long":      name = "int"
    if name == "int":       name = "int"
    if name == "double":    name = "float"
    if name == "unsigned":  name = "int"
    if name == "DOMString": name = "string"
    if name == "String":    name = "string"
    if name in AnyTypes:    name = "any"

    if name == "Array":
        return {
            "name": "any",
            "rank": 1
        }

    result = {}
    result["name"] = name

    if name != origName: result["originalName"] = origName

    if rank:
        if (rank == "[]"):
            result["rank"] = 1
        else:
            error("currently only one dimensional arrays are supported: %s" % name)

    return result

#--------------------------------------------------------------------
def clean(content):
    content = PatternCommentsPP.sub("", content)
    content = PatternPreprocessor.sub("", content)
    content = PatternNewLine.sub("", content)
    content = PatternComments.sub("", content)

    return content

#--------------------------------------------------------------------
def log(message):
    message = "%s: %s" % (PROGRAM_NAME, message)
    print >>sys.stderr, message

#--------------------------------------------------------------------
def error(message):
    log(message)
    sys.exit(-1)

#--------------------------------------------------------------------
PROGRAM_NAME = os.path.basename(sys.argv[0])

PatternComments          = re.compile(r"/\*.*?\*/")
PatternCommentsPP        = re.compile(r"//.*$", re.MULTILINE)
PatternPreprocessor      = re.compile(r"^\s*#.*$", re.MULTILINE)
PatternNewLine           = re.compile(r"\n")
PatternWhiteSpace        = re.compile(r"\s")
PatternModule            = re.compile(r".*?\bmodule\b(.*?){(.*)")
PatternInterface         = re.compile(r".*?\binterface\b\s*(\[.*?\])?\s*(\w+)\s*{(.*?)}\s*;(.*)")
PatternMethod            = re.compile(r".*?(\[.*?\])?\s*(\w+)([\[\]\s]*)\s+(\w+)\s*\((.*?)\)\s*;?(.*)")
PatternAttribute         = re.compile(r".*?(\[.*?\])?\s*\battribute\s+(\w+)([\[\]\s]*)\s+(\w+)\s*;?(.*)")
PatternParameter         = re.compile(r".*?(\w+)([\[\]\s]*)\s+(\w+)(\s+(\w+))?")
PatternExtendedAttribute = re.compile(r"\s*(\w+)\s*(=\s*(\w+))?\s*")

BuiltInTypes = "void any boolean int float string".split()
AnyTypes     = "Object DOMObject".split()

main()