#!/usr/bin/python
# Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
# for details. All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.

"""This module providesfunctionality for systems to generate
Elemental interfaces from the IDL database."""

import pdb
import os
import json
import systembaseelemental
from generator_java import *


class ElementalJsoSystem(systembaseelemental.SystemElemental):

  def __init__(self, templates, database, emitters, output_dir):
    super(ElementalJsoSystem, self).__init__(
        templates, database, emitters, output_dir)
    self._dart_interface_file_paths = []

  def InterfaceGenerator(self,
                         interface,
                         common_prefix,
                         super_interface_name,
                         source_filter):
    """."""

    module = getModule(interface.annotations)
    if super_interface_name is not None:
      interface_name = super_interface_name
    else:
      interface_name = interface.id

    template_file = 'jso_impl_%s.darttemplate' % interface_name
    template = self._templates.TryLoad(template_file)
    if not template:
      template = self._templates.Load('jso_impl.darttemplate')

    if interface_name in self._mixins or interface_name.endswith("Callback") or interface_name.endswith('Handler'):
      return NullInterfaceGenerator(module, self._database,
        interface, None,
        template,
        common_prefix, super_interface_name,
        source_filter)

    dart_interface_file_path = self._FilePathForElementalInterface(module, interface_name)

    self._dart_interface_file_paths.append(dart_interface_file_path)

    dart_interface_code = self._emitters.FileEmitter(dart_interface_file_path)

    return ElementalInterfaceGenerator(module, self._database,
        interface, dart_interface_code,
        template,
        common_prefix, super_interface_name,
        source_filter, self._mixins)

  def ProcessCallback(self, interface, info):
    pass


  def _FilePathForElementalInterface(self, module, interface_name):
    """Returns the file path of the Dart interface definition."""
    return os.path.join(self._output_dir, 'src', 'elemental', "js", module,
                        'Js%s.java' % interface_name)


# ------------------------------------------------------------------------------
# Used to suppress generation of JSO classes that are not needed
class NullInterfaceGenerator(systembaseelemental.ElementalBase):
  def __init__(self, module, database, interface, emitter, template,
               common_prefix, super_interface, source_filter):
    pass

  def StartInterface(self):
    pass
  def AddOperation(self, x, inherited):
    pass

  def AddIndexer(self, x):
    pass

  def AddConstant(self, x):
    pass

  def AddAttribute(self, x, y, inheritedGetter, inheritedSetter):
    pass

  def FinishInterface(self):
    pass


class ElementalInterfaceGenerator(systembaseelemental.ElementalBase):
  """Generates Elemental Interface definition for one DOM IDL interface."""

  def __init__(self, module, database, interface, emitter, template,
               common_prefix, super_interface, source_filter, mixins):
    """Generates Dart code for the given interface.

    Args:
      interface -- an IDLInterface instance. It is assumed that all types have
        been converted to Dart types (e.g. int, String), unless they are in the
        same package as the interface.
      common_prefix -- the prefix for the common library, if any.
      super_interface -- the name of the common interface that this interface
        implements, if any.
      source_filter -- if specified, rewrites the names of any superinterfaces
        that are not from these sources to use the common prefix.
    """
    super(self.__class__, self).__init__()
    self._module = module
    self._database = database
    self._interface = interface
    self._emitter = emitter
    self._template = template
    self._common_prefix = common_prefix
    self._super_interface = super_interface
    self._source_filter = source_filter
    self._mixins = mixins

    current_dir = os.path.dirname(__file__)
    self._docdatabase = json.load(open(os.path.join(current_dir, '..', 'docs/database.json')))


  def addImport(self, imports, typeid):
      # skip primitive types that are all lowercase first letter
      etype = DartType(typeid)

      if '<' not in typeid and etype[0].isupper():
        rawtype = etype.split('<')[0]

        if rawtype in ['Indexable', 'Settable', 'Mappable']:
          pmodule = 'util'
          imports['import elemental.js.%s.%s;\n' % (pmodule, 'Js' + rawtype)]=1
          imports['import elemental.%s.%s;\n' % (pmodule, rawtype)]=1
        elif etype not in java_lang and self._database.HasInterface(typeid):
          pinterface = self._database.GetInterface(typeid)
          pmodule = getModule(pinterface.annotations)
          if pmodule != self._module and not rawtype.endswith("Callback") and not rawtype.endswith("Handler") and not rawtype == 'EventTarget':
            imports['import elemental.js.%s.%s;\n' % (pmodule, 'Js' + rawtype)]=1
          imports['import elemental.%s.%s;\n' % (pmodule, rawtype)]=1

  def StartInterface(self):
    if self._super_interface:
      typename = self._super_interface
    else:
      typename = self._interface.id


    implements = []
    implements_raw = {}
    extends = ''
    suppressed_extends = []
    imports = {}

    alreadyImplemented = {}        
    for p in self._interface.parents:
      self.getImplements(alreadyImplemented, p)

    for attr in self._interface.attributes:
      self.addImport(imports, attr.type.id)

    for oper in self._interface.operations:
      self.addImport(imports, oper.type.id)
      for arg in oper.arguments:
        self.addImport(imports, arg.type.id)

    for parent in self._interface.parents:
      if not parent.type.id in alreadyImplemented or parent.type.id == 'ElementalMixinBase':
        self.addImport(imports, parent.type.id)
      # TODO(vsm): Remove source_filter.
        rawtype = DartType(parent.type.id).split('<')[0]
        if rawtype == 'Object':
          continue
        if MatchSourceFilter(self._source_filter, parent) and DartType(parent.type.id) != 'Object' and rawtype not in implements_raw:
          # Parent is a DOM type.
          implements.append(DartType(parent.type.id))
          implements_raw[rawtype]=1

#TODO(cromwellian) add in Indexable/IndexableInt/IndexableNumber
#      elif '<' in parent.type.id:
        # Parent is a Dart collection type.
        # TODO(vsm): Make this check more robust.
#        extends.append(parent.type.id)
#      else:
#        suppressed_extends.append('%s.%s' %
#                                  (self._common_prefix, parent.type.id))

    comment = ' extends'

    implements_str = ''

    # the Mixin base class is special, it extends JSO
    if self._interface.id == 'ElementalMixinBase':
      extends = ' extends JsElementalBase'
      filtered_mixins = []
      for mixin in self._mixins:
        filtered_mixins.append(DartType(mixin))
      implements.extend(filtered_mixins)
    else:
      # default, every type extends the Mixin base
      extends = ' extends JsElementalMixinBase'
    
    rawtype = DartType(self._interface.id).split('<')[0]
    if rawtype not in implements_raw and rawtype != 'Object':
      implements.insert(0, DartType(self._interface.id))
    self.addImport(imports, self._interface.id)

    # parents[0] is the implementing superclass, if exists, but not a mixin, reference its JSO impl
    if len(self._interface.parents) > 0 and not self._interface.parents[0].type.id in self._mixins:
      extends = ' extends Js' + DartType(self._interface.parents[0].type.id)
      self.addImport(imports, self._interface.parents[0].type.id)

    if implements:
      implements_str += ' implements ' + ', '.join(implements)
      comment = ','

    factory_provider = None
    constructor_info = AnalyzeConstructor(self._interface)

    # TODO(vsm): Add appropriate package / namespace syntax.
    (self._members_emitter,
     self._top_level_emitter) = self._emitter.Emit(
         self._template + '$!TOP_LEVEL',
         ID='Js' + typename,
         IMPLEMENTS=implements_str,
         EXTENDS=extends, PACKAGE='elemental.js.' + self._module,
         IMPORTS = ''.join(imports.keys()))

# TODO(cromwellian) auto-generate factory classes?

#    if constructor_info:
#      self._members_emitter.Emit(
#          '\n'
#          '  $CTOR($PARAMS);\n',
#          CTOR=typename,
#          PARAMS=constructor_info.ParametersInterfaceDeclaration());

#    element_type = MaybeTypedArrayElementType(self._interface)
#    if element_type:
#      self._members_emitter.Emit(
#          '\n'
#          '  $CTOR(int length);\n'
#          '\n'
#          '  $CTOR.fromList(List<$TYPE> list);\n'
#          '\n'
#          '  $CTOR.fromBuffer(ArrayBuffer buffer,'
#                            ' [int byteOffset, int length]);\n',
#          CTOR=self._interface.id,
#          TYPE=DartType(element_type))


  def FinishInterface(self):
     # add all create* method implementations to Document
     if self._interface.id == 'Document':
       for iface in self._database.GetInterfaces():
         if iface.id.endswith("Element"):
           # try to determine tag name from interface name
           elementName = iface.id;
           elementName = elementName[0:len(elementName) - len("Element")].lower()
           # tablecaption -> <caption>
           if elementName == 'tablecaption':
             elementName = 'caption'
           # SVG is special, it needs createElementNS, strip off prefix
           if elementName.startswith("svg"):
             elementName = elementName[3:]
             # special case, SVGElement is a root class, not a createable element
             if elementName != '':
               callName = DartType(iface.id)
               # SVGSVGElement -> createSVGElement with tag as <svg>
               if elementName == 'svg':
                 callName = 'SVGElement'
               self._members_emitter.Emit('\n  public final Js$TYPE create$CALL() {\n    return createSvgElement("$ELEMENT").cast();\n  }\n',
                                          TYPE=DartType(iface.id),
                                          CALL = callName,
                                          ELEMENT=elementName)
           elif elementName != '':
               self._members_emitter.Emit('\n  public final Js$TYPE create$TYPE() {\n    return createElement("$ELEMENT").cast();\n  }\n',
                                          TYPE=DartType(iface.id),
                                          ELEMENT=elementName)
     if self._interface.id == 'Window':
       for iface in self._database.GetInterfaces():
         element_type = MaybeTypedArrayElementType(iface)
         if element_type:
           self._members_emitter.Emit(
           '\n'
           '  public final native Js$TYPE new$CTOR(int length) /*-{ return new $TYPE(length); }-*/;\n'
           '\n'
           '  public final native Js$TYPE new$CTOR(IndexableNumber list) /*-{ return new $TYPE(list); }-*/;\n'
           '\n'
           '  public final native Js$TYPE new$CTOR(ArrayBuffer buffer,'
           ' int byteOffset, int length) /*-{ return new $TYPE(buffer, byteOffset, length); }-*/;\n',
           CTOR=iface.id,
           TYPE=iface.id)
         constructor_info = AnalyzeConstructor(iface)
         if constructor_info:
           self._members_emitter.Emit(
             '\n'
             '  public final native Js$TYPE new$CTOR($PARAMS) /*-{ return new $TYPE($ARGS); }-*/;\n',
             TYPE=iface.id,
             CTOR=iface.id,
             PARAMS=constructor_info.ParametersInterfaceDeclaration(),
             ARGS=constructor_info.ParametersAsArgumentList(self._database));


  def AddConstant(self, constant):
    pass

  def AddAttribute(self, getter, setter, inheritedGetter, inheritedSetter):
    # you can't override methods in a JSO superclass
    if getter and not inheritedGetter:
      if getter.type.id == 'EventListener':
        self._members_emitter.Emit('\n  public final native $TYPE $NAME() /*-{\n    return @elemental.js.dom.JsElementalMixinBase::getListenerFor(Lcom/google/gwt/core/client/JavaScriptObject;)(this.$FIELD);\n  }-*/;\n',
                                   NAME=getterName(getter),
                                   TYPE=TypeOrVar(DartType(getter.type.id),
                                                  getter.type.id),
                                   FIELD=getter.id)
      else:
        field = 'this.$FIELD'
        if getter.id in self.reserved_keywords:
          field_template = "this['$FIELD']"
        else:
          field_template = "this.$FIELD"
        self._members_emitter.Emit('\n  public final native $TYPE $NAME() /*-{\n    return %s;\n  }-*/;\n' % field_template ,
                                   NAME=getterName(getter),
                                   TYPE=JsoTypeOrVar(DartType(getter.type.id), self._mixins),
                                   FIELD=getter.id)
    if setter and not inheritedSetter:
        if setter.type.id == 'EventListener':
          self._members_emitter.Emit('\n  public final native void $NAME($TYPE listener) /*-{\n    this.$FIELD = @elemental.js.dom.JsElementalMixinBase::getHandlerFor(Lelemental/events/EventListener;)(listener);\n  }-*/;',
                                     NAME=setterName(setter),
                                     TYPE=TypeOrVar(DartType(setter.type.id),
                                                    setter.type.id),
                                     FIELD=setter.type.id)
        else:
          if setter.id in self.reserved_keywords:
            field_template = "this['$FIELD']"
          else:
            field_template = "this.$FIELD"
          self._members_emitter.Emit('\n  public final native void $NAME($TYPE param_$FIELD) /*-{\n    %s = param_$FIELD;\n  }-*/;\n' % field_template,
                                     NAME=setterName(setter),
                                     TYPE=TypeOrVar(DartType(setter.type.id)),
                                     FIELD=setter.id)

  def AddIndexer(self, element_type):
    # Interface inherits all operations from List<element_type>.
    pass

  def AddOperation(self, info, inherited):
    """
    Arguments:
      operations - contains the overloads, one or more operations with the same
        name.
    """
    # you can't override methods on a JSO superclass
    if inherited:
      return
    # implemented on mixin base template (hack)
    if info.name == 'addEventListener' or info.name == 'removeEventListener':
      return

    get_attrs = []
    set_attrs = []
    for attr in self._interface.attributes:
      get_attrs.append(getterName(attr))
      set_attrs.append('set%s' % ucfirst(attr.id))

    if info.name in get_attrs or info.name in set_attrs:
      return
    body = ''
    if info.type_name != 'void':
      body += 'return '
#    if op.is_fc_deleter:
#            w('delete ')
#     if info.id is None:
#            w('this[')
#        else:
    args = info.ParametersAsArgumentList(self._database)
    if info.name in self.reserved_keywords:
      body += "this['%s'](%s" % (info.name, args)
    else:
      body += 'this.%s(%s' % (info.name, args)


    #if op.id is None:
#            w('];\n')
#        else:
    body += ');'

    self._members_emitter.Emit('\n  public final native $TYPE $NAME($PARAMS) /*-{\n    $BODY\n  }-*/;\n',
                               TYPE=JsoTypeOrVar(info.type_name, self._mixins),
                               NAME=self.fixReservedKeyWords(info.name),
                               PARAMS=info.ParametersInterfaceDeclaration(),
                               BODY=body)

  def AddStaticOperation(self, info, inherited):
    pass

  # Interfaces get secondary members directly via the superinterfaces.
  def AddSecondaryAttribute(self, interface, getter, setter):
    pass

  def AddSecondaryOperation(self, interface, attr):
    pass


def ucfirst(string):
  """Upper cases the 1st character in a string"""
  if len(string):
    return '%s%s' % (string[0].upper(), string[1:])
  return string

def getterName(attr):
  name = DartDomNameOfAttribute(attr)
  if attr.type.id == 'boolean':
    if name.startswith('is'):
      name = name[2:]
    return 'is%s' % ucfirst(name)
  return 'get%s' % ucfirst(name)

def setterName(attr):
  name = DartDomNameOfAttribute(attr)
  return 'set%s' % ucfirst(name)


def getModule(annotations):
  htmlaliases = ['audio', 'webaudio', 'inspector', 'offline', 'p2p', 'window', 'websockets', 'threads', 'view', 'storage', 'fileapi']

  module = "dom"
  if 'WebKit' in annotations and 'module' in annotations['WebKit']:
    module = annotations['WebKit']['module']
  if module in  htmlaliases:
    return "html"
  if module == 'core':
    return 'dom'
  return module

java_lang = ['Object', 'String', 'Exception', 'DOMTimeStamp', 'DOMString']