/*
 * Copyright 2024-2025 LiveKit, Inc.
 *
 * 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 io.livekit.android.selfie

import android.app.Application
import android.graphics.drawable.BitmapDrawable
import androidx.annotation.OptIn
import androidx.appcompat.content.res.AppCompatResources
import androidx.camera.camera2.interop.ExperimentalCamera2Interop
import androidx.camera.core.ImageAnalysis
import androidx.camera.core.resolutionselector.AspectRatioStrategy
import androidx.camera.core.resolutionselector.ResolutionSelector
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ProcessLifecycleOwner
import io.livekit.android.LiveKit
import io.livekit.android.LiveKitOverrides
import io.livekit.android.room.track.CameraPosition
import io.livekit.android.room.track.LocalVideoTrack
import io.livekit.android.room.track.LocalVideoTrackOptions
import io.livekit.android.room.track.video.CameraCapturerUtils
import io.livekit.android.track.processing.video.RVMNcnn
import io.livekit.android.util.LoggingLevel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.asExecutor
import livekit.org.webrtc.CameraXHelper
import livekit.org.webrtc.EglBase

@OptIn(ExperimentalCamera2Interop::class)
class MainViewModel(application: Application) : AndroidViewModel(application) {
    val eglBase = EglBase.create()
    private val processor = RVMNcnn(eglBase)
    init {
        LiveKit.loggingLevel = LoggingLevel.INFO

    }


    val room = LiveKit.create(
        application,
        overrides = LiveKitOverrides(
            eglBase = eglBase,
        ),
    )

    private val virtualBackground = (AppCompatResources.getDrawable(application, R.drawable.background) as BitmapDrawable).bitmap

    private var blur = 16f


    private var cameraProvider: CameraCapturerUtils.CameraProvider? = null

    private var imageAnalysis = ImageAnalysis.Builder()
        .setResolutionSelector(
            ResolutionSelector.Builder()
                // LocalVideoTrack has default aspect ratio 16:9 VideoPreset169.H720
                // ImageAnalysis of CameraX has default aspect ratio 4:3
                .setAspectRatioStrategy(AspectRatioStrategy.RATIO_16_9_FALLBACK_AUTO_STRATEGY)
                .build(),
        )
        .build()

    init {
        CameraXHelper.createCameraProvider(ProcessLifecycleOwner.get(), arrayOf(imageAnalysis)).let {
            if (it.isSupported(application)) {
                CameraCapturerUtils.registerCameraProvider(it)
                cameraProvider = it
            }
        }
    }

    val track = MutableLiveData<LocalVideoTrack?>(null)

    fun startCapture() {
        val videoTrack = room.localParticipant.createVideoTrack(
            options = LocalVideoTrackOptions(position = CameraPosition.FRONT),
            videoProcessor = processor,
        )

        videoTrack.startCapture()
        track.postValue(videoTrack)
    }

    override fun onCleared() {
        super.onCleared()
        track.value?.stopCapture()
        room.release()
        processor.dispose()
        cameraProvider?.let {
            CameraCapturerUtils.unregisterCameraProvider(it)
        }
    }

    fun toggleProcessor(): Boolean {
        val newState = !processor.enabled
        processor.enabled = newState
        return newState
    }

    fun decreaseBlur() {
        // RVMNcnn 不支持 blur 调整；保留方法以兼容示例 UI，改为无操作日志
        blur = maxOf(0f, blur - 5)
        android.util.Log.e("MainViewModel", "RVMNcnn: decreaseBlur noop, current blur=$blur, enabled=${processor.enabled}")
    }

    fun increaseBlur() {
        // RVMNcnn 不支持 blur 调整；保留方法以兼容示例 UI，改为无操作日志
        blur = minOf(50f, blur + 5)
        android.util.Log.e("MainViewModel", "RVMNcnn: increaseBlur noop, current blur=$blur, enabled=${processor.enabled}")
    }

    fun toggleVirtualBackground(): Boolean {
        // 使用 RVMNcnn 的背景图接口
        // 返回 true 表示设置了背景，false 表示清除
        val videoTrack = track.value
        return if (videoTrack != null) {
            // 简单切换：如果当前未设置则设置，已设置则清除
            // 这里无法直接读取 native 状态，使用布尔切换可根据 UI 状态驱动
            val set = processor.updateBackgroundImage(virtualBackground)
            if (!set) {
                processor.updateBackgroundImage(null)
            }
            set
        } else {
            // 未开始采集时可直接设置
            processor.updateBackgroundImage(virtualBackground)
        }
    }

    fun flipCamera() {
        val videoTrack = track.value ?: return
        val newPosition = when (videoTrack.options.position) {
            CameraPosition.FRONT -> CameraPosition.BACK
            CameraPosition.BACK -> CameraPosition.FRONT
            else -> CameraPosition.FRONT
        }
        videoTrack.switchCamera(position = newPosition)
    }
}