/*
 * Copyright (C) 2023 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 android.hardware.input

import android.content.Context
import android.content.ContextWrapper
import android.content.res.Resources
import android.platform.test.annotations.Presubmit
import android.view.Display
import android.view.DisplayInfo
import android.view.InputDevice
import androidx.test.core.app.ApplicationProvider
import com.android.test.input.MockInputManagerRule
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNotNull
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.Mockito
import org.mockito.Mockito.eq
import org.mockito.Mockito.`when`
import org.mockito.junit.MockitoJUnitRunner

/**
 * Tests for [InputManager].
 *
 * Build/Install/Run: atest InputTests:InputManagerTest
 */
@Presubmit
@RunWith(MockitoJUnitRunner::class)
class InputManagerTest {

    companion object {
        const val DEVICE_ID = 42
        const val SECOND_DEVICE_ID = 96
        const val THIRD_DEVICE_ID = 99
    }

    @get:Rule val inputManagerRule = MockInputManagerRule()

    private lateinit var devicesChangedListener: IInputDevicesChangedListener
    private val deviceGenerationMap = mutableMapOf<Int /*deviceId*/, Int /*generation*/>()
    private lateinit var context: Context
    private lateinit var inputManager: InputManager

    @Before
    fun setUp() {
        context = Mockito.spy(ContextWrapper(ApplicationProvider.getApplicationContext()))
        inputManager = InputManager(context)
        `when`(context.getSystemService(eq(Context.INPUT_SERVICE))).thenReturn(inputManager)
        `when`(inputManagerRule.mock.inputDeviceIds).then { deviceGenerationMap.keys.toIntArray() }
    }

    private fun notifyDeviceChanged(
        deviceId: Int,
        associatedDisplayId: Int,
        usiVersion: HostUsiVersion?,
    ) {
        val generation =
            deviceGenerationMap[deviceId]?.plus(1)
                ?: throw IllegalArgumentException("Device $deviceId was never added!")
        deviceGenerationMap[deviceId] = generation

        `when`(inputManagerRule.mock.getInputDevice(deviceId))
            .thenReturn(createInputDevice(deviceId, associatedDisplayId, usiVersion, generation))
        val list = deviceGenerationMap.flatMap { listOf(it.key, it.value) }
        if (::devicesChangedListener.isInitialized) {
            devicesChangedListener.onInputDevicesChanged(list.toIntArray())
        }
    }

    private fun addInputDevice(
        deviceId: Int,
        associatedDisplayId: Int,
        usiVersion: HostUsiVersion?,
    ) {
        deviceGenerationMap[deviceId] = 0
        notifyDeviceChanged(deviceId, associatedDisplayId, usiVersion)
    }

    @Test
    fun testUsiVersionDisplayAssociation() {
        addInputDevice(DEVICE_ID, Display.DEFAULT_DISPLAY, null)
        addInputDevice(SECOND_DEVICE_ID, Display.INVALID_DISPLAY, HostUsiVersion(9, 8))
        addInputDevice(THIRD_DEVICE_ID, 42, HostUsiVersion(3, 1))

        val usiVersion = inputManager.getHostUsiVersion(createDisplay(42))
        assertNotNull(usiVersion)
        assertEquals(3, usiVersion!!.majorVersion)
        assertEquals(1, usiVersion.minorVersion)
    }

    @Test
    fun testUsiVersionFallBackToDisplayConfig() {
        addInputDevice(DEVICE_ID, Display.DEFAULT_DISPLAY, null)

        `when`(inputManagerRule.mock.getHostUsiVersionFromDisplayConfig(eq(42)))
            .thenReturn(HostUsiVersion(9, 8))
        val usiVersion = inputManager.getHostUsiVersion(createDisplay(42))
        assertEquals(HostUsiVersion(9, 8), usiVersion)
    }
}

private fun createInputDevice(
    deviceId: Int,
    associatedDisplayId: Int,
    usiVersion: HostUsiVersion? = null,
    generation: Int = -1,
): InputDevice =
    InputDevice.Builder()
        .setId(deviceId)
        .setName("Device $deviceId")
        .setDescriptor("descriptor $deviceId")
        .setAssociatedDisplayId(associatedDisplayId)
        .setUsiVersion(usiVersion)
        .setGeneration(generation)
        .build()

private fun createDisplay(displayId: Int): Display {
    val res: Resources? = null
    return Display(null /* global */, displayId, DisplayInfo(), res)
}