/*
 * Copyright (C) 2022 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.settings.spa.notification

import android.Manifest
import android.app.INotificationManager
import android.app.NotificationChannel
import android.app.NotificationManager.IMPORTANCE_DEFAULT
import android.app.NotificationManager.IMPORTANCE_NONE
import android.app.NotificationManager.IMPORTANCE_UNSPECIFIED
import android.app.admin.DevicePolicyManager
import android.app.usage.IUsageStatsManager
import android.app.usage.UsageEvents
import android.content.ComponentName
import android.content.Context
import android.content.pm.ApplicationInfo
import android.os.Build
import android.os.UserHandle
import android.platform.test.annotations.EnableFlags
import android.platform.test.flag.junit.SetFlagsRule

import androidx.test.core.app.ApplicationProvider
import androidx.test.ext.junit.runners.AndroidJUnit4

import com.android.settings.flags.Flags
import com.android.settings.R
import com.android.settingslib.spaprivileged.model.app.IPackageManagers
import com.android.settingslib.spaprivileged.model.app.userId
import com.google.common.truth.Truth.assertThat

import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.runTest

import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith

import org.mockito.Mock
import org.mockito.junit.MockitoJUnit
import org.mockito.junit.MockitoRule
import org.mockito.kotlin.any
import org.mockito.kotlin.eq
import org.mockito.kotlin.spy
import org.mockito.kotlin.verify
import org.mockito.kotlin.whenever

@RunWith(AndroidJUnit4::class)
class AppNotificationRepositoryTest {
    @get:Rule
    val mockito: MockitoRule = MockitoJUnit.rule()

    @get:Rule val setFlagsRule = SetFlagsRule()

    private val context: Context = spy(ApplicationProvider.getApplicationContext()) {}
    private val testAdminComponent: ComponentName = ComponentName("testAdmin", "DO")
    private val user: UserHandle = context.getUser()
    private val pkg: String = context.getPackageName()

    @Mock
    private lateinit var packageManagers: IPackageManagers

    @Mock
    private lateinit var usageStatsManager: IUsageStatsManager

    @Mock
    private lateinit var notificationManager: INotificationManager

    @Mock
    private lateinit var devicePolicyManager: DevicePolicyManager

    private lateinit var repository: AppNotificationRepository

    @Before
    fun setUp() {
        whenever(context.getSystemService(eq(Context.DEVICE_POLICY_SERVICE))).thenReturn(devicePolicyManager)
        whenever(context.createPackageContextAsUser(eq(pkg), any(), eq(user))).thenReturn(context)
        whenever(devicePolicyManager.getDeviceOwnerUser()).thenReturn(user)
        whenever(devicePolicyManager.getDeviceOwnerComponentOnAnyUser()).thenReturn(null)

        repository = AppNotificationRepository(
            context,
            packageManagers,
            usageStatsManager,
            notificationManager,
            dpm = devicePolicyManager,
        )
    }

    private fun mockOnlyHasDefaultChannel(): NotificationChannel {
        whenever(notificationManager.onlyHasDefaultChannel(APP.packageName, APP.uid))
            .thenReturn(true)
        val channel =
            NotificationChannel(NotificationChannel.DEFAULT_CHANNEL_ID, null, IMPORTANCE_DEFAULT)
        whenever(
            notificationManager.getNotificationChannelForPackage(
                APP.packageName, APP.uid, NotificationChannel.DEFAULT_CHANNEL_ID, null, true
            )
        ).thenReturn(channel)
        return channel
    }

    private fun mockIsEnabled(app: ApplicationInfo, enabled: Boolean) {
        whenever(notificationManager.areNotificationsEnabledForPackage(app.packageName, app.uid))
            .thenReturn(enabled)
    }

    private fun mockChannelCount(app: ApplicationInfo, count: Int) {
        whenever(
            notificationManager.getNumNotificationChannelsForPackage(
                app.packageName,
                app.uid,
                false,
            )
        ).thenReturn(count)
    }

    private fun mockBlockedChannelCount(app: ApplicationInfo, count: Int) {
        whenever(notificationManager.getBlockedChannelCount(app.packageName, app.uid))
            .thenReturn(count)
    }

    private fun mockSentCount(app: ApplicationInfo, sentCount: Int) {
        val events = (1..sentCount).map {
            UsageEvents.Event().apply {
                mEventType = UsageEvents.Event.NOTIFICATION_INTERRUPTION
            }
        }
        whenever(
            usageStatsManager.queryEventsForPackageForUser(
                any(), any(), eq(app.userId), eq(app.packageName), any()
            )
        ).thenReturn(UsageEvents(events, arrayOf()))
    }

    @Test
    fun getAggregatedUsageEvents() = runTest {
        val events = listOf(
            UsageEvents.Event().apply {
                mEventType = UsageEvents.Event.NOTIFICATION_INTERRUPTION
                mPackage = PACKAGE_NAME
                mTimeStamp = 2
            },
            UsageEvents.Event().apply {
                mEventType = UsageEvents.Event.NOTIFICATION_INTERRUPTION
                mPackage = PACKAGE_NAME
                mTimeStamp = 3
            },
            UsageEvents.Event().apply {
                mEventType = UsageEvents.Event.NOTIFICATION_INTERRUPTION
                mPackage = PACKAGE_NAME
                mTimeStamp = 6
            },
        )
        whenever(usageStatsManager.queryEventsForUser(any(), any(), eq(USER_ID), any()))
            .thenReturn(UsageEvents(events, arrayOf()))

        val usageEvents = repository.getAggregatedUsageEvents(flowOf(USER_ID)).first()

        assertThat(usageEvents).containsExactly(
            PACKAGE_NAME, NotificationSentState(lastSent = 6, sentCount = 3),
        )
    }

    @Test
    fun isEnabled() {
        mockIsEnabled(app = APP, enabled = true)

        val isEnabled = repository.isEnabled(APP)

        assertThat(isEnabled).isTrue()
    }

    @Test
    fun isChangeable_importanceLocked() {
        whenever(notificationManager.isImportanceLocked(APP.packageName, APP.uid)).thenReturn(true)

        val isChangeable = repository.isChangeable(APP)

        assertThat(isChangeable).isFalse()
    }

    @Test
    fun isChangeable_appTargetS() {
        val targetSApp = ApplicationInfo().apply {
            targetSdkVersion = Build.VERSION_CODES.S
        }

        val isChangeable = repository.isChangeable(targetSApp)

        assertThat(isChangeable).isTrue()
    }

    @Test
    fun isChangeable_appTargetTiramisuWithoutNotificationPermission() {
        val targetTiramisuApp = ApplicationInfo().apply {
            targetSdkVersion = Build.VERSION_CODES.TIRAMISU
        }
        with(packageManagers) {
            whenever(targetTiramisuApp.hasRequestPermission(Manifest.permission.POST_NOTIFICATIONS))
                .thenReturn(false)
        }

        val isChangeable = repository.isChangeable(targetTiramisuApp)

        assertThat(isChangeable).isFalse()
    }

    @Test
    fun isChangeable_appTargetTiramisuWithNotificationPermission() {
        val targetTiramisuApp = ApplicationInfo().apply {
            targetSdkVersion = Build.VERSION_CODES.TIRAMISU
        }
        with(packageManagers) {
            whenever(targetTiramisuApp.hasRequestPermission(Manifest.permission.POST_NOTIFICATIONS))
                .thenReturn(true)
        }

        val isChangeable = repository.isChangeable(targetTiramisuApp)

        assertThat(isChangeable).isTrue()
    }

    @Test
    @EnableFlags(Flags.FLAG_NOTIFICATION_USE_DPC_POLICY)
    fun isChangeable_devicePolicyPrompt() {
        whenever(notificationManager.isImportanceLocked(APP.packageName, APP.uid)).thenReturn(false)
        whenever(devicePolicyManager.getDeviceOwnerComponentOnAnyUser()).thenReturn(testAdminComponent)
        whenever(devicePolicyManager.getPermissionPolicy(testAdminComponent)).thenReturn(DevicePolicyManager.PERMISSION_POLICY_PROMPT)

        val isChangeable = repository.isChangeable(APP)

        assertThat(isChangeable).isTrue()
    }

    @Test
    @EnableFlags(Flags.FLAG_NOTIFICATION_USE_DPC_POLICY)
    fun isChangeable_devicePolicyAutoGrant() {
        whenever(notificationManager.isImportanceLocked(APP.packageName, APP.uid)).thenReturn(false)
        whenever(devicePolicyManager.getDeviceOwnerComponentOnAnyUser()).thenReturn(testAdminComponent)
        whenever(devicePolicyManager.getPermissionPolicy(testAdminComponent)).thenReturn(DevicePolicyManager.PERMISSION_POLICY_AUTO_GRANT)

        val isChangeable = repository.isChangeable(APP)

        assertThat(isChangeable).isFalse()
    }

    @Test
    @EnableFlags(Flags.FLAG_NOTIFICATION_USE_DPC_POLICY)
    fun isChangeable_devicePolicyAutoDeny() {
        whenever(notificationManager.isImportanceLocked(APP.packageName, APP.uid)).thenReturn(false)
        whenever(devicePolicyManager.getDeviceOwnerComponentOnAnyUser()).thenReturn(testAdminComponent)
        whenever(devicePolicyManager.getPermissionPolicy(testAdminComponent)).thenReturn(DevicePolicyManager.PERMISSION_POLICY_AUTO_DENY)

        val isChangeable = repository.isChangeable(APP)

        assertThat(isChangeable).isFalse()
    }

    @Test
    fun setEnabled_toTrueWhenOnlyHasDefaultChannel() {
        val channel = mockOnlyHasDefaultChannel()

        repository.setEnabled(app = APP, enabled = true)

        verify(notificationManager)
            .updateNotificationChannelForPackage(APP.packageName, APP.uid, channel)
        assertThat(channel.importance).isEqualTo(IMPORTANCE_UNSPECIFIED)
    }

    @Test
    fun setEnabled_toFalseWhenOnlyHasDefaultChannel() {
        val channel = mockOnlyHasDefaultChannel()

        repository.setEnabled(app = APP, enabled = false)

        verify(notificationManager)
            .updateNotificationChannelForPackage(APP.packageName, APP.uid, channel)
        assertThat(channel.importance).isEqualTo(IMPORTANCE_NONE)
    }

    @Test
    fun setEnabled_toTrueWhenNotOnlyHasDefaultChannel() {
        whenever(notificationManager.onlyHasDefaultChannel(APP.packageName, APP.uid))
            .thenReturn(false)

        repository.setEnabled(app = APP, enabled = true)

        verify(notificationManager)
            .setNotificationsEnabledForPackage(APP.packageName, APP.uid, true)
    }

    @Test
    fun getNotificationSummary_notEnabled() {
        mockIsEnabled(app = APP, enabled = false)

        val summary = repository.getNotificationSummary(APP)

        assertThat(summary).isEqualTo(context.getString(R.string.notifications_disabled))
    }

    @Test
    fun getNotificationSummary_noChannel() {
        mockIsEnabled(app = APP, enabled = true)
        mockChannelCount(app = APP, count = 0)
        mockSentCount(app = APP, sentCount = 1)

        val summary = repository.getNotificationSummary(APP)

        assertThat(summary).isEqualTo("About 1 notification per week")
    }

    @Test
    fun getNotificationSummary_allChannelsBlocked() {
        mockIsEnabled(app = APP, enabled = true)
        mockChannelCount(app = APP, count = 2)
        mockBlockedChannelCount(app = APP, count = 2)

        val summary = repository.getNotificationSummary(APP)

        assertThat(summary).isEqualTo(context.getString(R.string.notifications_disabled))
    }

    @Test
    fun getNotificationSummary_noChannelBlocked() {
        mockIsEnabled(app = APP, enabled = true)
        mockChannelCount(app = APP, count = 2)
        mockSentCount(app = APP, sentCount = 2)
        mockBlockedChannelCount(app = APP, count = 0)

        val summary = repository.getNotificationSummary(APP)

        assertThat(summary).isEqualTo("About 2 notifications per week")
    }

    @Test
    fun getNotificationSummary_someChannelsBlocked() {
        mockIsEnabled(app = APP, enabled = true)
        mockChannelCount(app = APP, count = 2)
        mockSentCount(app = APP, sentCount = 3)
        mockBlockedChannelCount(app = APP, count = 1)

        val summary = repository.getNotificationSummary(APP)

        assertThat(summary).isEqualTo("About 3 notifications per week / 1 category turned off")
    }

    @Test
    fun calculateFrequencySummary_daily() {
        val summary = repository.calculateFrequencySummary(4)

        assertThat(summary).isEqualTo("About 1 notification per day")
    }

    @Test
    fun calculateFrequencySummary_weekly() {
        val summary = repository.calculateFrequencySummary(3)

        assertThat(summary).isEqualTo("About 3 notifications per week")
    }

    @Test
    fun hasSentMessageNotification_yesValid() {
        whenever(notificationManager.hasSentValidMsg(APP.packageName, APP.uid)).thenReturn(true)

        assertThat(repository.hasSentMessageNotification(APP)).isTrue()
    }

    @Test
    fun hasSentMessageNotification_yesInvalid() {
        whenever(notificationManager.isInInvalidMsgState(APP.packageName, APP.uid)).thenReturn(true)

        assertThat(repository.hasSentMessageNotification(APP)).isTrue()
    }

    @Test
    fun hasSentMessageNotification_no() {
        assertThat(repository.hasSentMessageNotification(APP)).isFalse()
    }

    private companion object {
        const val USER_ID = 0
        const val PACKAGE_NAME = "package.name"
        val APP = ApplicationInfo().apply {
            packageName = PACKAGE_NAME
            uid = 123
        }
    }
}