/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed 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.
 */
@file:JvmName("RecipeMergeUtils")

package com.android.tools.idea.templates

import com.android.SdkConstants.ATTR_ID
import com.android.SdkConstants.ATTR_NAME
import com.android.SdkConstants.FN_ANDROID_MANIFEST_XML
import com.android.SdkConstants.XMLNS_PREFIX
import com.android.manifmerger.ManifestMerger2
import com.android.manifmerger.MergingReport
import com.android.manifmerger.XmlDocument
import com.android.resources.ResourceFolderType
import com.android.tools.idea.templates.recipe.RenderingContext
import com.android.utils.StdLogger
import com.android.utils.XmlUtils
import com.google.common.base.Charsets
import com.google.common.collect.Lists.newArrayList
import com.intellij.lang.xml.XMLLanguage
import com.intellij.openapi.diagnostic.Logger
import com.intellij.openapi.diagnostic.logger
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.io.FileUtil
import com.intellij.openapi.util.text.StringUtil
import com.intellij.psi.PsiFileFactory
import com.intellij.psi.codeStyle.CodeStyleManager
import com.intellij.psi.xml.XmlComment
import com.intellij.psi.xml.XmlFile
import com.intellij.psi.xml.XmlTag
import com.intellij.psi.xml.XmlTagChild
import com.intellij.psi.xml.XmlText
import java.io.ByteArrayInputStream
import java.io.File
import java.io.FileNotFoundException
import java.io.InputStream

/**
 * Utility methods to support the recipe.xml merge instruction.
 */

private val LOG: Logger get() = logger(::LOG)

private const val MERGE_ATTR_STRATEGY = "templateMergeStrategy"
private const val MERGE_ATTR_STRATEGY_REPLACE = "replace"
private const val MERGE_ATTR_STRATEGY_PRESERVE = "preserve"

/**
 * Merges sourceXml into targetXml/targetFile (targetXml is the contents of targetFile).
 * @return the resulting xml if it still needs to be written to targetFile or null if the file has already been/doesn't need to be updated.
 */
fun mergeXml(context: RenderingContext, sourceXml: String, targetXml: String, targetFile: File): String {
  val fileName = targetFile.name
  var errors: String? = null

  fun mergeManifest(): String? {
    XmlUtils.parseDocumentSilently(targetXml, true) ?: error("$targetXml failed to parse")
    XmlUtils.parseDocumentSilently(sourceXml, true) ?: error("$sourceXml failed to parse")
    val report = mergeManifest(context.moduleRoot!!, targetFile, targetXml, sourceXml) ?: return null
    if (report.result.isSuccess) {
      return report.getMergedDocument(MergingReport.MergedManifestKind.MERGED)
    }
    // report.reportString isn't useful, it just says to look at the logs
    // Also, some of the warnings are misleading -- e.g. "missing package declaration";
    // that's deliberate. Users only have to deal with errors to get the manifest merge to succeed.
    errors = report.loggingRecords.asSequence()
      .filter { it.severity == MergingReport.Record.Severity.ERROR }
      .joinToString("") { "* ${it.message}\n\n" }
      .replace("AndroidManifest.xml", "current AndroidManifest.xml") // Error messages may refer to our internal temp name for the target manifest file
      .replace("nevercreated.xml", "template AndroidManifest.xml")
      .trim()
    return null
  }

  fun mergePlainXml(): String {
    val parentFolderName = targetFile.parentFile.name
    val folderType = ResourceFolderType.getFolderType(parentFolderName)
    // mergeResourceFile handles the file updates itself
    return mergeResourceFile(context.project, context.warnings, targetXml, sourceXml, fileName, folderType)
  }

  return (if (fileName == FN_ANDROID_MANIFEST_XML) mergeManifest() else mergePlainXml())
         ?: // Just insert into file along with comment, using the "standard" conflict syntax that many tools and editors recognize.
         wrapWithMergeConflict(targetXml, sourceXml).also {
           context.warnings.add(
             "Merge conflict for: ${targetFile.name}\nThis file must be fixed by hand. Errors encountered during the merge:\n\n$errors")
         }
}

/**
 * Merges the given resource file contents into the given resource file
 */
fun mergeResourceFile(project: Project,
                      warningsToAdd: MutableCollection<String>,
                      targetXml: String,
                      sourceXml: String,
                      fileName: String,
                      folderType: ResourceFolderType?): String {
  val targetPsiFile = PsiFileFactory.getInstance(project)
    .createFileFromText("targetFile", XMLLanguage.INSTANCE, StringUtil.convertLineSeparators(targetXml), false, true) as XmlFile
  val sourcePsiFile = PsiFileFactory.getInstance(project)
    .createFileFromText("sourceFile", XMLLanguage.INSTANCE, StringUtil.convertLineSeparators(sourceXml), false, true) as XmlFile
  val root = targetPsiFile.document!!.rootTag ?: error("Cannot find XML root in target: $targetXml")

  val attributes = sourcePsiFile.rootTag!!.attributes
  attributes.filter {it.namespacePrefix == XMLNS_PREFIX}.forEach { root.setAttribute(it.name, it.value) }

  if (folderType != ResourceFolderType.VALUES) {
    // In other file types, such as layouts, just append all the new content at the end.
    sourcePsiFile.rootTag!!.children.filterIsInstance<XmlTag>().forEach {
      root.addSubTag(it, false)
    }
    return targetPsiFile.text
  }

  val prependElements = newArrayList<XmlTagChild>()
  var indent: XmlText? = null
  // Try to merge items of the same name
  val old = root.subTags.associateBy { getResourceId(it) }
  loop@ for (child in sourcePsiFile.rootTag!!.children) {
    when (child) {
      is XmlComment -> {
        if (indent != null) {
          prependElements.add(indent)
        }
        prependElements.add(child as XmlTagChild)
      }
      is XmlText -> indent = child
      is XmlTag -> {
        var subTag = child
        val mergeStrategy = subTag.getAttributeValue(MERGE_ATTR_STRATEGY)
        subTag.setAttribute(MERGE_ATTR_STRATEGY, null)
        // remove the space left by the deleted attribute
        CodeStyleManager.getInstance(project).reformat(subTag)
        val name = getResourceId(subTag)
        val replace = if (name == null) null else old[name]
        if (replace == null) {
          if (indent != null) {
            prependElements.add(indent)
          }
          subTag = root.addSubTag(subTag, false)
          prependElements.forEach {
            root.addBefore(it, subTag)
          }
          prependElements.clear()
          continue@loop
        }
        // There is an existing item with the same id. Either replace it  or preserve it depending on the "templateMergeStrategy" attribute.
        // If that attribute does not exist, default to preserving it.

        // Let's say you've used the activity wizard once, and it  emits some configuration parameter as a resource that
        // it depends on, say "padding". Then the user goes and  tweaks the padding to some other number.
        // Now running the wizard a *second* time for some new activity, we should NOT go and set the value back to the template's default!
        when {
          MERGE_ATTR_STRATEGY_REPLACE == mergeStrategy -> {
            val newChild = replace.replace(child)
            // When we're replacing, the line is probably already indented. Skip the initial indent
            if (newChild.prevSibling is XmlText && prependElements[0] is XmlText) {
              prependElements.removeAt(0)
              // If we're adding something we'll need a newline/indent after it
              if (prependElements.isNotEmpty()) {
                prependElements.add(indent)
              }
            }
            for (element in prependElements) {
              root.addBefore(element, newChild)
            }
          }
          MERGE_ATTR_STRATEGY_PRESERVE == mergeStrategy -> {
            // Preserve the existing value.
          }
          replace.text.trim() == child.text.trim() -> {
            // There are no differences, do not issue a warning.
          }
          else -> // No explicit directive given, preserve the original value by default.
            warningsToAdd.add("Ignoring conflict for the value: $name wanted: \"%${child.text}\" but it already is: \"%${replace.text}\" in the file: $fileName")
        }
        prependElements.clear()
      }
    }
  }

  return targetPsiFile.text
}

/**
 * Merges the given manifest fragment into the given manifest file
 */
private fun mergeManifest(moduleRoot: File, targetManifest: File,
                          targetXml: String, mergeText: String): MergingReport? {
  try {
    val isMasterManifest = FileUtil.filesEqual(moduleRoot, targetManifest.parentFile)

    val tempFile2 = File(targetManifest.parentFile, "nevercreated.xml")
    val logger = StdLogger(StdLogger.Level.INFO)
    return ManifestMerger2.newMerger(targetManifest, logger, ManifestMerger2.MergeType.APPLICATION)
      .withFeatures(ManifestMerger2.Invoker.Feature.EXTRACT_FQCNS,
                    ManifestMerger2.Invoker.Feature.HANDLE_VALUE_CONFLICTS_AUTOMATICALLY,
                    ManifestMerger2.Invoker.Feature.NO_PLACEHOLDER_REPLACEMENT)
      .addFlavorAndBuildTypeManifest(tempFile2)
      .asType(if (isMasterManifest) XmlDocument.Type.MAIN else XmlDocument.Type.OVERLAY)
      .withFileStreamProvider(object : ManifestMerger2.FileStreamProvider() {
        @Throws(FileNotFoundException::class)
        override fun getInputStream(file: File): InputStream {
          val text = if (FileUtil.filesEqual(file, targetManifest)) targetXml else mergeText
          return ByteArrayInputStream(text.toByteArray(Charsets.UTF_8))
        }
      })
      .merge()
  }
  catch (e: ManifestMerger2.MergeFailureException) {
    LOG.warn(e)
    return null
  }
}

private fun getResourceId(tag: XmlTag): String? = tag.getAttributeValue(ATTR_NAME) ?: tag.getAttributeValue(ATTR_ID)

/**
 * Wraps the given strings in the standard conflict syntax
 */
private fun wrapWithMergeConflict(original: String, added: String): String =
  "<<<<<<< Original\n$original\n=======\n$added>>>>>>> Added\n"