"""IntelliJ plugin target rule.

Creates a plugin jar with the given plugin xml and any
optional plugin xmls.

To provide optional plugin xmls, use the 'optional_plugin_xml'
rule. These will be renamed, put in the META-INF directory,
and the main plugin xml stamped with optional plugin dependencies
that point to the correct META-INF optional plugin xmls.

optional_plugin_xml(
  name = "optional_python_xml",
  plugin_xml = "my_optional_python_plugin.xml",
  module = "com.idea.python.module.id",
)

intellij_plugin(
  name = "my_plugin",
  plugin_xml = ["my_plugin.xml"],
  optional_plugin_xmls = [":optional_python_xml"],
  deps = [
    ":code_deps",
  ],
)

"""

optional_plugin_xml_provider = provider()

def _optional_plugin_xml_impl(ctx):
  attr = ctx.attr
  optional_plugin_xmls = []
  if ctx.file.plugin_xml:
    optional_plugin_xmls.append(struct(
        plugin_xml = ctx.file.plugin_xml,
        module = attr.module,
    ))
  return struct(
      optional_plugin_xml_data = optional_plugin_xml_provider(
          optional_plugin_xmls = optional_plugin_xmls,
      ),
  )

optional_plugin_xml = rule(
    implementation = _optional_plugin_xml_impl,
    attrs = {
        "plugin_xml": attr.label(mandatory=True, allow_single_file=[".xml"]),
        "module": attr.string(mandatory=True),
    },
)

def _merge_optional_plugin_xmls(ctx):
  # Collect optional plugin xmls
  module_to_xmls = {}
  for target in ctx.attr.optional_plugin_xmls:
    if not hasattr(target, "optional_plugin_xml_data"):
      fail("optional_plugin_xmls only accepts optional_plugin_xml targets")
    for xml in target.optional_plugin_xml_data.optional_plugin_xmls:
      module = xml.module
      plugin_xmls = module_to_xmls.setdefault(module, [])
      plugin_xmls.append(xml.plugin_xml)

  # Merge xmls with the same module dependency
  module_to_merged_xmls = {}
  for module, plugin_xmls in module_to_xmls.items():
    merged_name = "merged_xml_for_" + module + "_" + ctx.label.name + ".xml"
    merged_file = ctx.new_file(merged_name)
    ctx.action(
        executable = ctx.executable._merge_xml_binary,
        arguments = ["--output", merged_file.path] + [plugin_xml.path for plugin_xml in plugin_xmls],
        inputs = list(plugin_xmls),
        outputs = [merged_file],
        progress_message = "Merging optional xmls",
        mnemonic = "MergeOptionalXmls",
    )
    module_to_merged_xmls[module] = merged_file
  return module_to_merged_xmls

def _add_optional_dependencies_to_plugin_xml(ctx, modules):
  input_plugin_xml_file = ctx.file.plugin_xml
  if not modules:
    return input_plugin_xml_file

  # Add optional dependencies into the plugin xml
  args = []
  final_plugin_xml_file = ctx.new_file("final_plugin_xml_" + ctx.label.name + ".xml")
  args.extend(["--plugin_xml", input_plugin_xml_file.path])
  args.extend(["--output", final_plugin_xml_file.path])
  for module in modules:
    args.append(module)
    args.append(_filename_for_module_dependency(module))
  ctx.action(
      executable = ctx.executable._append_optional_xml_elements,
      arguments = args,
      inputs = [input_plugin_xml_file],
      outputs = [final_plugin_xml_file],
      progress_message = "Adding optional dependencies to final plugin xml",
      mnemonic = "AddModuleDependencies",
  )
  return final_plugin_xml_file

def _only_file(target):
  return list(target.files)[0]

def _filename_for_module_dependency(module):
  """A unique filename for the optional xml dependency for a given module."""
  return "optional-" + module + ".xml"

def _package_meta_inf_files(ctx, final_plugin_xml_file, module_to_merged_xmls):
  jar_name = ctx.attr.jar_name
  jar_file = ctx.new_file(jar_name)

  args = []
  args.extend(["--deploy_jar", ctx.file.deploy_jar.path])
  args.extend(["--output", jar_file.path])
  args.extend([final_plugin_xml_file.path, "plugin.xml"])
  for module, merged_xml in module_to_merged_xmls.items():
    args.append(merged_xml.path)
    args.append(_filename_for_module_dependency(module))
  ctx.action(
      executable = ctx.executable._package_meta_inf_files,
      arguments = args,
      inputs = [ctx.file.deploy_jar, final_plugin_xml_file] + module_to_merged_xmls.values(),
      outputs = [jar_file],
      mnemonic = "PackagePluginJar",
      progress_message = "Packaging plugin jar",
  )
  return jar_file

def _intellij_plugin_jar_impl(ctx):
  module_to_merged_xmls = _merge_optional_plugin_xmls(ctx)
  final_plugin_xml_file = _add_optional_dependencies_to_plugin_xml(ctx, module_to_merged_xmls.keys())
  jar_file = _package_meta_inf_files(ctx, final_plugin_xml_file, module_to_merged_xmls)
  files = set([jar_file])
  return struct(
      files = files,
  )

_intellij_plugin_jar = rule(
    implementation = _intellij_plugin_jar_impl,
    attrs = {
        "deploy_jar": attr.label(mandatory=True, allow_single_file=[".jar"]),
        "plugin_xml": attr.label(mandatory=True, allow_single_file=[".xml"]),
        "optional_plugin_xmls": attr.label_list(),
        "jar_name": attr.string(mandatory=True),
        "_merge_xml_binary": attr.label(
            default = Label("//build_defs:merge_xml"),
            executable = True,
            cfg = "host",
        ),
        "_append_optional_xml_elements": attr.label(
            default = Label("//build_defs:append_optional_xml_elements"),
            executable = True,
            cfg = "host",
        ),
        "_package_meta_inf_files": attr.label(
            default = Label("//build_defs:package_meta_inf_files"),
            executable = True,
            cfg = "host",
        ),
    },
)

def intellij_plugin(name, deps, plugin_xml, optional_plugin_xmls=[], jar_name=None, **kwargs):
  """Creates an intellij plugin from the given deps and plugin.xml.

  Args:
    name: The name of the target
    deps: Any java dependencies rolled up into the plugin jar.
    plugin_xml: An xml file to be placed in META-INF/plugin.jar
    optional_plugin_xmls: A list of optional_plugin_xml targets.
    jar_name: The name of the final plugin jar, or <name>.jar if None
    **kwargs: Any further arguments to be passed to the final target
  """
  binary_name = name + "_binary"
  deploy_jar = binary_name + "_deploy.jar"
  native.java_binary(
      name = binary_name,
      runtime_deps = deps,
      create_executable = 0,
  )
  jar_target_name =  name + "_intellij_plugin_jar"
  _intellij_plugin_jar(
      name = jar_target_name,
      deploy_jar = deploy_jar,
      jar_name = jar_name or (name + ".jar"),
      plugin_xml = plugin_xml,
      optional_plugin_xmls = optional_plugin_xmls,
  )
  # included (with tag) as a hack so that IJwB can recognize this is an intellij plugin
  native.java_import(
      name = name,
      jars = [jar_target_name],
      tags = ["intellij-plugin"],
      **kwargs)

def _append_optional_dependencies(name, plugin_xml, module_to_merged_xml):
  """Appends optional dependency xml elements to plugin xml."""
  append_elements_tool = "//build_defs:append_optional_xml_elements"
  args = [
      "./$(location {append_elements_tool})",
      "--plugin_xml=$(location {plugin_xml})",
      "--optional_xml_files={merged_optional_xml_files}",
  ]
  dictionary = {k: _filename_for_module_dependency(k) for k in module_to_merged_xml.keys()}
  cmd = " ".join(args).format(
      append_elements_tool=append_elements_tool,
      plugin_xml=plugin_xml,
      merged_optional_xml_files='"%s"' % str(dictionary).replace('"', '\\"'),
  ) + "> $@"

  srcs = module_to_merged_xml.values() + [plugin_xml]

  native.genrule(
      name = name,
      srcs = srcs,
      outs = [name + ".xml"],
      cmd = cmd,
      tools = [append_elements_tool],
  )