/*
 * Copyright (C) 2018 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.
 */

package com.android.tools.lint.checks

import com.android.SdkConstants
import com.android.SdkConstants.ANDROID_PKG
import com.android.SdkConstants.ANDROID_URI
import com.android.SdkConstants.ATTR_NAME
import com.android.SdkConstants.ATTR_THEME
import com.android.SdkConstants.CLASS_ACTIVITY
import com.android.SdkConstants.TAG_APPLICATION
import com.android.SdkConstants.TAG_ITEM
import com.android.SdkConstants.TAG_STYLE
import com.android.resources.ResourceFolderType
import com.android.resources.ResourceType
import com.android.resources.ResourceUrl
import com.android.sdklib.AndroidVersion
import com.android.tools.lint.client.api.ResourceReference
import com.android.tools.lint.detector.api.Category
import com.android.tools.lint.detector.api.Detector
import com.android.tools.lint.detector.api.Implementation
import com.android.tools.lint.detector.api.Issue
import com.android.tools.lint.detector.api.JavaContext
import com.android.tools.lint.detector.api.Scope
import com.android.tools.lint.detector.api.Severity
import com.android.tools.lint.detector.api.SourceCodeScanner
import com.android.tools.lint.detector.api.XmlContext
import com.android.tools.lint.detector.api.XmlScanner
import com.android.tools.lint.detector.api.resolveManifestName
import com.android.utils.XmlUtils
import com.intellij.psi.PsiMethod
import org.jetbrains.uast.UCallExpression
import org.jetbrains.uast.UClass
import org.jetbrains.uast.getParentOfType
import org.w3c.dom.Attr
import org.w3c.dom.Element
import java.util.EnumSet

const val ATTR_SCREEN_ORIENTATION = "screenOrientation"

/** Detects potential bugs such as the one described in b/b/33483680 */
class TranslucentViewDetector : Detector(), XmlScanner, SourceCodeScanner {
    companion object Issues {
        /** Mixing Translucency and Orientation  */
        @JvmField
        val ISSUE = Issue.create(
            id = "TranslucentOrientation",
            briefDescription = "Mixing screenOrientation and translucency",
            explanation = """
            Specifying a fixed screen orientation with a translucent theme isn't supported \
            on apps with `targetSdkVersion` O or greater since there can be an another activity \
            visible behind your activity with a conflicting request.

            For example, your activity requests landscape and the visible activity behind \
            your translucent activity request portrait. In this case the system can only \
            honor one of the requests and currently prefers to honor the request from \
            non-translucent activities since there is nothing visible behind them.

            Devices running platform version O or greater will throw an exception in your \
            app if this state is detected.
            """,
            category = Category.CORRECTNESS,
            priority = 8,
            severity = Severity.WARNING,
            implementation = Implementation(
                TranslucentViewDetector::class.java,
                EnumSet.of(Scope.MANIFEST, Scope.ALL_RESOURCE_FILES, Scope.JAVA_FILE)
            )
        )
    }

    private var interestingActivities: MutableList<String>? = null
    private var interestingThemes: MutableList<String>? = null
    private var defaultTheme: String? = null

    override fun getApplicableAttributes(): Collection<String>? = listOf(ATTR_SCREEN_ORIENTATION)
    override fun getApplicableElements(): Collection<String>? = listOf(TAG_STYLE)
    override fun appliesTo(folderType: ResourceFolderType): Boolean {
        return folderType == ResourceFolderType.VALUES
    }

    override fun visitAttribute(context: XmlContext, attribute: Attr) {
        if (context.mainProject.targetSdk < AndroidVersion.VersionCodes.O) {
            return
        }

        // If anyone specifies screenOrientation (other than "unspecified"), then
        // write down the theme applied on this activity.  (If theme is not specified,
        // look it up in the activity or worst of all, use default in manifest)
        if (SdkConstants.ANDROID_URI != attribute.namespaceURI) {
            return
        }

        val value = attribute.value
        if (value == "unspecified") {
            return
        }

        val activity = attribute.ownerElement
        if (activity == null || !activity.hasAttributeNS(ANDROID_URI, ATTR_NAME)) {
            return
        }
        val name = resolveManifestName(activity)

        val theme = activity.getAttributeNS(ANDROID_URI, ATTR_THEME)
        if (theme.isBlank()) {
            val application = activity.parentNode as? Element
            defaultTheme = getThemeName(application?.getAttributeNS(ANDROID_URI, ATTR_THEME))
            addActivity(name)
        } else {
            addTheme(getThemeName(theme))
        }
    }

    private fun addActivity(name: String) {
        val activities = interestingActivities ?: run {
            val newList = mutableListOf<String>()
            interestingActivities = newList
            newList
        }
        activities.add(name)
    }

    private fun addTheme(theme: String?) {
        theme ?: return
        val themes = interestingThemes ?: run {
            val newList = mutableListOf<String>()
            interestingThemes = newList
            newList
        }
        themes.add(theme)
    }

    private fun getThemeName(themeUrl: String?): String? {
        themeUrl ?: return null

        // TODO(namespaces)
        val theme = ResourceUrl.parse(themeUrl)
        return if (theme?.type == ResourceType.STYLE && !theme.isFramework) {
            theme.name
        } else {
            null
        }
    }

    override fun visitElement(context: XmlContext, element: Element) {
        val themes = interestingThemes

        if (themes == null && defaultTheme == null) {
            return
        }

        if (context.mainProject.targetSdk < AndroidVersion.VersionCodes.O) {
            return
        }

        // TODO: Need full map to chase parent pointers etc
        val themeName = element.getAttribute(ATTR_NAME)
        if (themeName == defaultTheme || themes != null && themes.contains(themeName)) {
            // Look at children
            var curr = XmlUtils.getFirstSubTagByName(element, TAG_ITEM)
            while (curr != null) {
                val attributeName = curr.getAttribute(ATTR_NAME)
                if (attributeName == "android:windowIsFloating" ||
                    attributeName == "windowIsTranslucent"
                ) {
                    val attributeNode = curr.getAttributeNode(ATTR_NAME)
                    val location = context.getValueLocation(attributeNode)
                    // TODO: look up the manifest location too and attach it here
                    // TODO: Consider going about this from the other end: if we find
                    // a theme occurrence, THEN look up merged manifest to see if it's referenced
                    // from an interesting manifest location!

                    val mergedManifest = context.mainProject.mergedManifest
                    if (mergedManifest != null) {
                        val application = XmlUtils.getFirstSubTagByName(
                            mergedManifest.documentElement, TAG_APPLICATION
                        )
                        var currentActivity = XmlUtils.getFirstSubTag(application)
                        while (currentActivity != null) {
                            val attr = currentActivity.getAttributeNodeNS(
                                ANDROID_URI,
                                ATTR_SCREEN_ORIENTATION
                            )
                            // TODO - pick the one that doesn't specify unspecified (and ideally
                            // map back to the same activity that contributed the activity,
                            // which is why it might make sense to compute forwards instead.)
                            if (attr != null) {
                                val secondary = context.getValueLocation(attr)
                                location.secondary = secondary
                                break
                            }

                            currentActivity = XmlUtils.getNextTag(currentActivity)
                        }
                    }

                    val message = "Should not specify screen orientation with translucent or " +
                            "floating theme"
                    context.report(ISSUE, curr, location, message)
                    break
                }

                curr = XmlUtils.getNextTagByName(curr, TAG_ITEM)
            }
        }
    }

    // In Java/Kotlin files, look for setTheme() calls in activities listed in
    // interestingActivities

    override fun getApplicableMethodNames(): List<String>? {
        return listOf("setTheme")
    }

    override fun visitMethodCall(context: JavaContext, node: UCallExpression, method: PsiMethod) {
        val activities = interestingActivities ?: return
        val uClass = node.getParentOfType<UClass>(UClass::class.java, true) ?: return
        if (!activities.contains(uClass.qualifiedName)) {
            return
        }

        if (!context.evaluator.inheritsFrom(uClass, CLASS_ACTIVITY, false)) {
            return
        }
        val arguments = node.valueArguments
        if (arguments.size != 1) {
            return
        }
        val reference = ResourceReference.get(arguments[0])
        if (reference?.type == ResourceType.STYLE && reference.`package` != ANDROID_PKG) {
            addTheme(reference.name)

            // We've already processed resources, so handle it in a second pass
            context.driver.requestRepeat(this, Scope.ALL_RESOURCES_SCOPE)
        }
    }
}