/*
 * Copyright 2020 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 androidx.camera.camera2.pipe.impl

import android.hardware.camera2.CameraAccessException
import android.hardware.camera2.CameraCaptureSession
import android.hardware.camera2.CaptureFailure
import android.hardware.camera2.CaptureRequest
import android.hardware.camera2.CaptureResult
import android.hardware.camera2.TotalCaptureResult
import android.util.ArrayMap
import android.view.Surface
import androidx.annotation.GuardedBy
import androidx.camera.camera2.pipe.CameraGraph
import androidx.camera.camera2.pipe.CameraId
import androidx.camera.camera2.pipe.CameraTimestamp
import androidx.camera.camera2.pipe.FrameNumber
import androidx.camera.camera2.pipe.Metadata
import androidx.camera.camera2.pipe.Request
import androidx.camera.camera2.pipe.RequestMetadata
import androidx.camera.camera2.pipe.RequestNumber
import androidx.camera.camera2.pipe.RequestTemplate
import androidx.camera.camera2.pipe.StreamId
import androidx.camera.camera2.pipe.wrapper.CameraCaptureSessionWrapper
import androidx.camera.camera2.pipe.wrapper.ObjectUnavailableException
import androidx.camera.camera2.pipe.writeParameters
import kotlinx.atomicfu.atomic
import java.util.Collections.singletonList
import java.util.Collections.singletonMap
import javax.inject.Inject

/**
 * An instance of a RequestProcessor exists for the duration of a CameraCaptureSession and must be
 * created for each new CameraCaptureSession. It is responsible for low level interactions with the
 * CameraCaptureSession and for shimming the interfaces and callbacks to make them easier to work
 * with. Unlike the CameraCaptureSessionProxy interface the RequestProcessor has more liberty to
 * change the standard Camera2 API contract to make it easier to work with.
 *
 * There are some important design considerations:
 * - Instances class is not thread safe, although the companion object has some counters that are
 *   global and *are* thread safe.
 * - Special care is taken to reduce the number objects and wrappers that are created, and to reduce
 *   the number of loops and overhead in wrapper objects.
 * - Callbacks are expected to be invoked at very high frequency.
 * - One RequestProcessor instance per CameraCaptureSession
 */
interface RequestProcessor {

    /**
     * Submit a single [Request] with an optional set of extra parameters.
     *
     * @param request the request to submit to the camera.
     * @param extraRequestParameters extra parameters to apply to the request.
     * @param requireSurfacesForAllStreams if this flag is defined then this method will only submit
     *   the request if all streamIds can be mapped to valid surfaces. At least one surface is
     *   always required. This is useful if (for example) someone needs to quickly submit a
     *   request with a specific trigger or mode key but does not care about modifying the list of
     *   current surfaces.
     * @return false if this request failed to be submitted. If this method returns false, none of
     *   the callbacks on the Request(s) will be invoked.
     */
    fun submit(
        request: Request,
        extraRequestParameters: Map<CaptureRequest.Key<*>, Any>,
        requireSurfacesForAllStreams: Boolean
    ): Boolean

    /**
     * Submit a list of [Request]s with an optional set of extra parameters.
     *
     * @param requests the requests to submit to the camera.
     * @param extraRequestParameters extra parameters to apply to the request.
     * @param requireSurfacesForAllStreams if this flag is defined then this method will only submit
     *   the request if all streamIds can be mapped to valid surfaces. At least one surface is
     *   always required. This is useful if (for example) someone needs to quickly submit a
     *   request with a specific trigger or mode key but does not care about modifying the list of
     *   current surfaces.
     * @return false if this request failed to be submitted. If this method returns false, none of
     *   the callbacks on the Request(s) will be invoked.
     */
    fun submit(
        requests: List<Request>,
        extraRequestParameters: Map<CaptureRequest.Key<*>, Any>,
        requireSurfacesForAllStreams: Boolean
    ): Boolean

    /**
     * Set the repeating [Request] with an optional set of extra parameters.
     *
     * The current repeating request may not be executed at all, or it may be executed multiple
     * times. The repeating request is used as the base request for all 3A interactions which may
     * cause the request to be used to generate multiple [CaptureRequest]s to the camera.
     *
     * @param request the requests to set as the repeating request.
     * @param extraRequestParameters extra parameters to apply to the request.
     * @param requireSurfacesForAllStreams if this flag is defined then this method will only submit
     *   the request if all streamIds can be mapped to valid surfaces. At least one surface is
     *   always required. This is useful if (for example) someone needs to quickly submit a
     *   request with a specific trigger or mode key but does not care about modifying the list of
     *   current surfaces.
     * @return false if this request failed to be submitted. If this method returns false, none of
     *   the callbacks on the Request(s) will be invoked.
     */
    fun setRepeating(
        request: Request,
        extraRequestParameters: Map<CaptureRequest.Key<*>, Any>,
        requireSurfacesForAllStreams: Boolean
    ): Boolean

    /**
     * Abort requests that have been submitted but not completed.
     */
    fun abortCaptures()

    /**
     * Stops the current repeating request.
     */
    fun stopRepeating()

    /**
     * Puts the RequestProcessor into a closed state where it will reject all incoming requests.
     */
    fun close()

    interface Factory {
        fun create(
            session: CameraCaptureSessionWrapper,
            surfaceMap: Map<StreamId, Surface>
        ): RequestProcessor
    }
}

class StandardRequestProcessorFactory @Inject constructor(
    private val threads: Threads,
    private val graphConfig: CameraGraph.Config,
    @ForCameraGraph private val graphListeners: ArrayList<Request.Listener>,
    private val graphState3A: GraphState3A
) : RequestProcessor.Factory {
    override fun create(
        session: CameraCaptureSessionWrapper,
        surfaceMap: Map<StreamId, Surface>
    ): RequestProcessor =
        StandardRequestProcessor(
            session,
            threads,
            graphConfig,
            surfaceMap,
            graphListeners,
            graphState3A
        )
}

internal val requestProcessorDebugIds = atomic(0)
internal val requestSequenceDebugIds = atomic(0L)
internal val requestTags = atomic(0L)
internal fun nextRequestTag(): RequestNumber = RequestNumber(requestTags.incrementAndGet())

/**
 * This class is designed to synchronously handle interactions with the Camera CaptureSession.
 */
class StandardRequestProcessor(
    private val session: CameraCaptureSessionWrapper,
    private val threads: Threads,
    private val graphConfig: CameraGraph.Config,
    private val surfaceMap: Map<StreamId, Surface>,
    private val graphListeners: List<Request.Listener>,
    private val graphState3A: GraphState3A
) : RequestProcessor {

    @GuardedBy("inFlightRequests")
    private val inFlightRequests = mutableListOf<CaptureSequence>()
    private val debugId = requestProcessorDebugIds.incrementAndGet()
    private val closed = atomic(false)

    override fun submit(
        request: Request,
        extraRequestParameters: Map<CaptureRequest.Key<*>, Any>,
        requireSurfacesForAllStreams: Boolean
    ): Boolean {
        return configureAndCapture(
            singletonList(request),
            extraRequestParameters,
            requireSurfacesForAllStreams,
            isRepeating = false
        )
    }

    override fun submit(
        requests: List<Request>,
        extraRequestParameters: Map<CaptureRequest.Key<*>, Any>,
        requireSurfacesForAllStreams: Boolean
    ): Boolean {
        return configureAndCapture(
            requests,
            extraRequestParameters,
            requireSurfacesForAllStreams,
            isRepeating = false
        )
    }

    override fun setRepeating(
        request: Request,
        extraRequestParameters: Map<CaptureRequest.Key<*>, Any>,
        requireSurfacesForAllStreams: Boolean
    ): Boolean {
        return configureAndCapture(
            singletonList(request),
            extraRequestParameters,
            requireSurfacesForAllStreams,
            isRepeating = true
        )
    }

    override fun abortCaptures() {
        val requestsToAbort = synchronized(inFlightRequests) {
            val copy = inFlightRequests.toList()
            inFlightRequests.clear()
            copy
        }
        for (sequence in requestsToAbort) {
            sequence.invokeOnAborted()
        }
        session.abortCaptures()
    }

    override fun stopRepeating() {
        session.stopRepeating()
    }

    override fun close() {
        closed.compareAndSet(expect = false, update = true)
    }

    private fun configureAndCapture(
        requests: List<Request>,
        extras: Map<CaptureRequest.Key<*>, Any>,
        requireStreams: Boolean,
        isRepeating: Boolean
    ): Boolean {
        // Reject incoming requests if this instance has been stopped or closed.
        if (closed.value) {
            return false
        }

        val requestMap = ArrayMap<RequestNumber, RequestInfo>(requests.size)
        val captureRequests = ArrayList<CaptureRequest>(requests.size)

        val surfaceToStreamMap = ArrayMap<Surface, StreamId>()
        val streamToSurfaceMap = ArrayMap<StreamId, Surface>()

        for (request in requests) {
            val requestTemplate = request.template ?: graphConfig.template

            Log.debug { "Building CaptureRequest for $request" }

            // Check to see if there is at least one valid surface for each stream.
            var hasSurface = false
            for (stream in request.streams) {
                if (streamToSurfaceMap.contains(stream)) {
                    hasSurface = true
                    continue
                }

                val surface = surfaceMap[stream]
                if (surface != null) {
                    Log.debug { "  Binding $stream to $surface" }

                    // TODO(codelogic) There should be a more efficient way to do these lookups than
                    // having two maps.
                    surfaceToStreamMap[surface] = stream
                    streamToSurfaceMap[stream] = surface
                    hasSurface = true
                } else if (requireStreams) {
                    Log.info { "  Failed to bind surface to $stream" }
                    // If requireStreams is set we are required to map every stream to a valid
                    // Surface object for this request. If this condition is violated, then we
                    // return false because we cannot submit these request(s) until there is a valid
                    // StreamId -> Surface mapping for all streams.
                    return false
                }
            }

            // If there are no surfaces on a particular request, camera2 will now allow us to
            // submit it.
            if (!hasSurface) {
                return false
            }

            // Create the request builder. There is a risk this will throw an exception or return null
            // if the CameraDevice has been closed or disconnected. If this fails, indicate that the
            // request was not submitted.
            val requestBuilder: CaptureRequest.Builder
            try {
                requestBuilder = session.device.createCaptureRequest(requestTemplate)
            } catch (exception: ObjectUnavailableException) {
                return false
            }

            // Apply the output surfaces to the requestBuilder
            hasSurface = false
            for (stream in request.streams) {
                val surface = streamToSurfaceMap[stream]
                if (surface != null) {
                    requestBuilder.addTarget(surface)
                    hasSurface = true
                }
            }

            // Soundness check to make sure we add at least one surface. This should be guaranteed
            // because we are supposed to exit early and return false if we cannot map at least one
            // surface per request.
            check(hasSurface)

            // Apply the parameters to the requestBuilder
            requestBuilder.writeParameters(request.requestParameters)

            // Apply the 3A parameters first. This gives the users of camerapipe the ability to
            // still override the 3A parameters for complicated use cases.
            //
            // TODO(sushilnath@): Implement one of the two options. (1) Apply the 3A parameters
            // from internal 3A state machine at last and provide a flag in the Request object to
            // specify when the clients want to explicitly override some of the 3A parameters
            // directly. Add code to handle the flag. (2) Let clients override the 3A parameters
            // freely and when that happens intercept those parameters from the request and keep the
            // internal 3A state machine in sync.
            graphState3A.writeTo(requestBuilder)

            // Write extra parameters to the request. These parameters will overwite parameters
            // defined in the Request (if they overlap)
            requestBuilder.writeParameters(extras)

            // The tag must be set for every request. We use it to lookup listeners for the
            // individual requests so that each request can specify individual listeners.
            val requestTag = nextRequestTag()
            requestBuilder.setTag(requestTag)

            // Create the camera2 captureRequest and add it to our list of requests.
            val captureRequest = requestBuilder.build()
            captureRequests.add(captureRequest)

            @Suppress("SyntheticAccessor")
            requestMap[requestTag] = RequestInfo(
                captureRequest,
                emptyMap(),
                streamToSurfaceMap,
                requestTemplate,
                isRepeating,
                request,
                requestTag
            )
        }

        // Create the captureSequence listener
        @Suppress("SyntheticAccessor")
        val captureSequence = CaptureSequence(
            graphListeners,
            if (requests.size == 1) {
                singletonMap(requestMap.keyAt(0), requestMap.valueAt(0))
            } else {
                requestMap
            },
            captureRequests,
            surfaceToStreamMap,
            inFlightRequests,
            session.device.cameraId
        )

        // Non-repeating requests must always be aware of abort calls.
        if (!isRepeating) {
            synchronized(inFlightRequests) {
                inFlightRequests.add(captureSequence)
            }
        }

        var captured = false
        return try {

            Log.debug { "Submitting $captureSequence" }
            capture(captureRequests, captureSequence, isRepeating)
            captured = true
            Log.debug { "Submitted $captureSequence" }
            true
        } catch (closedException: ObjectUnavailableException) {
            false
        } catch (accessException: CameraAccessException) {
            false
        } finally {
            // If ANY unhandled exception occurs, don't throw, but make sure we remove it from the
            // list of in-flight requests.
            if (!captured && !isRepeating) {
                captureSequence.invokeOnAborted()
            }
        }
    }

    private fun capture(
        captureRequests: List<CaptureRequest>,
        captureSequence: CaptureSequence,
        isRepeating: Boolean
    ) {
        captureSequence.invokeOnRequestSequenceCreated()

        // NOTE: This is a funny synchronization call. The purpose is to avoid a rare but possible
        // situation where calling capture causes one of the callback methods to be invoked before
        // sequenceNumber has been set on the callback. Both this call and the synchronized
        // behavior on the CaptureSequence listener have been designed to minimize the number of
        // synchronized calls.
        synchronized(lock = captureSequence) {
            // TODO: Update these calls to use executors on newer versions of the OS
            val sequenceNumber: Int = if (captureRequests.size == 1) {
                if (isRepeating) {
                    session.setRepeatingRequest(
                        captureRequests[0],
                        captureSequence,
                        threads.camera2Handler
                    )
                } else {
                    session.capture(captureRequests[0], captureSequence, threads.camera2Handler)
                }
            } else {
                if (isRepeating) {
                    session.setRepeatingBurst(
                        captureRequests,
                        captureSequence,
                        threads.camera2Handler
                    )
                } else {
                    session.captureBurst(captureRequests, captureSequence, threads.camera2Handler)
                }
            }
            captureSequence.sequenceNumber = sequenceNumber
        }

        // Invoke callbacks without holding a lock.
        captureSequence.invokeOnRequestSequenceSubmitted()
    }

    override fun toString(): String {
        return "RequestProcessor-$debugId"
    }
}

/**
 * This class packages together information about a request that was submitted to the camera.
 */
@Suppress("SyntheticAccessor") // Using an inline class generates a synthetic constructor
internal class RequestInfo(
    private val captureRequest: CaptureRequest,
    private val extraRequestParameters: Map<Metadata.Key<*>, Any?>,
    override val streams: Map<StreamId, Surface>,
    override val template: RequestTemplate,
    override val repeating: Boolean,
    override val request: Request,
    override val requestNumber: RequestNumber
) : RequestMetadata {
    override fun <T> get(key: CaptureRequest.Key<T>): T? = captureRequest[key]
    override fun <T> getOrDefault(key: CaptureRequest.Key<T>, default: T): T =
        get(key) ?: default

    @Suppress("UNCHECKED_CAST")
    override fun <T> get(key: Metadata.Key<T>): T? = extraRequestParameters[key] as T?

    override fun <T> getOrDefault(key: Metadata.Key<T>, default: T): T = get(key) ?: default

    override fun unwrap(): CaptureRequest = captureRequest
}

/**
 * This class responds to events from a set of one or more requests. It uses the tag field on
 * a CaptureRequest object to lookup and invoke per-request listeners so that a listener can be
 * defined on a specific request within a burst.
 */
internal class CaptureSequence(
    private val internalListeners: List<Request.Listener>,
    private val requests: Map<RequestNumber, RequestInfo>,
    private val captureRequests: List<CaptureRequest>,
    private val surfaceMap: Map<Surface, StreamId>,
    private val inFlightRequests: MutableList<CaptureSequence>,
    private val camera: CameraId
) : CameraCaptureSession.CaptureCallback() {
    private val debugId = requestSequenceDebugIds.incrementAndGet()

    @Volatile
    private var _sequenceNumber: Int? = null
    var sequenceNumber: Int
        get() {
            if (_sequenceNumber == null) {
                // If the sequence id has not been submitted, it means the call to capture or
                // setRepeating has not yet returned. The callback methods should never be synchronously
                // invoked, so the only case this should happen is if a second thread attempted to
                // invoke one of the callbacks before the initial call completed. By locking against the
                // captureSequence object here and in the capture call, we can block the callback thread
                // until the sequenceId is available.
                synchronized(this) {
                    return checkNotNull(_sequenceNumber) {
                        "SequenceNumber has not been set for $this!"
                    }
                }
            }
            return checkNotNull(_sequenceNumber) {
                "SequenceNumber has not been set for $this!"
            }
        }
        set(value) {
            _sequenceNumber = value
        }

    override fun onCaptureStarted(
        captureSession: CameraCaptureSession,
        captureRequest: CaptureRequest,
        captureTimestamp: Long,
        captureFrameNumber: Long
    ) {
        val requestNumber = readRequestNumber(captureRequest)
        val timestamp = CameraTimestamp(captureTimestamp)
        val frameNumber = FrameNumber(captureFrameNumber)

        // Load the request and throw if we are not able to find an associated request. Under
        // normal circumstances this should never happen.
        val request = readRequest(requestNumber)

        invokeOnRequest(request) {
            it.onStarted(
                request,
                frameNumber,
                timestamp
            )
        }
    }

    override fun onCaptureProgressed(
        captureSession: CameraCaptureSession,
        captureRequest: CaptureRequest,
        partialCaptureResult: CaptureResult
    ) {
        val requestNumber = readRequestNumber(captureRequest)
        val frameNumber = FrameNumber(partialCaptureResult.frameNumber)
        val frameMetadata = AndroidFrameMetadata(partialCaptureResult, camera)

        // Load the request and throw if we are not able to find an associated request. Under
        // normal circumstances this should never happen.
        val request = readRequest(requestNumber)

        invokeOnRequest(request) {
            it.onPartialCaptureResult(
                request,
                frameNumber,
                frameMetadata
            )
        }
    }

    override fun onCaptureCompleted(
        captureSession: CameraCaptureSession,
        captureRequest: CaptureRequest,
        captureResult: TotalCaptureResult
    ) {
        // Remove this request from the set of requests that are currently tracked.
        synchronized(inFlightRequests) {
            inFlightRequests.remove(this)
        }

        val requestNumber = readRequestNumber(captureRequest)
        val frameNumber = FrameNumber(captureResult.frameNumber)

        // Load the request and throw if we are not able to find an associated request. Under
        // normal circumstances this should never happen.
        val request = readRequest(requestNumber)

        val frameInfo = AndroidFrameInfo(
            captureResult,
            camera,
            request
        )

        invokeOnRequest(request) {
            it.onTotalCaptureResult(
                request,
                frameNumber,
                frameInfo
            )
        }
    }

    override fun onCaptureFailed(
        captureSession: CameraCaptureSession,
        captureRequest: CaptureRequest,
        captureFailure: CaptureFailure
    ) {
        // Remove this request from the set of requests that are currently tracked.
        synchronized(inFlightRequests) {
            inFlightRequests.remove(this)
        }

        val requestNumber = readRequestNumber(captureRequest)
        val frameNumber = FrameNumber(captureFailure.frameNumber)

        // Load the request and throw if we are not able to find an associated request. Under
        // normal circumstances this should never happen.
        val request = readRequest(requestNumber)

        invokeOnRequest(request) {
            it.onFailed(
                request,
                frameNumber,
                captureFailure
            )
        }
    }

    override fun onCaptureBufferLost(
        captureSession: CameraCaptureSession,
        captureRequest: CaptureRequest,
        surface: Surface,
        frameId: Long
    ) {
        val requestNumber = readRequestNumber(captureRequest)
        val frameNumber = FrameNumber(frameId)
        val streamId = checkNotNull(surfaceMap[surface]) {
            "Unable to find the streamId for $surface on frame $frameNumber"
        }

        // Load the request and throw if we are not able to find an associated request. Under
        // normal circumstances this should never happen.
        val request = readRequest(requestNumber)

        invokeOnRequest(request) {
            it.onBufferLost(
                request,
                frameNumber,
                streamId
            )
        }
    }

    /**
     * Custom implementation that informs all listeners that the request had not completed when
     * abort was called.
     */
    fun invokeOnAborted() {
        invokeOnRequests { request, _, listener ->
            listener.onAborted(request.request)
        }
    }

    fun invokeOnRequestSequenceCreated() {
        invokeOnRequests { request, _, listener ->
            listener.onRequestSequenceCreated(request)
        }
    }

    fun invokeOnRequestSequenceSubmitted() {
        invokeOnRequests { request, _, listener ->
            listener.onRequestSequenceSubmitted(request)
        }
    }

    override fun onCaptureSequenceCompleted(
        captureSession: CameraCaptureSession,
        captureSequenceId: Int,
        captureFrameNumber: Long
    ) {
        check(sequenceNumber == captureSequenceId) {
            "Complete was invoked on $sequenceNumber, but the sequence was not fully submitted!"
        }
        synchronized(inFlightRequests) {
            inFlightRequests.remove(this)
        }

        val frameNumber = FrameNumber(captureFrameNumber)
        invokeOnRequests { request, _, listener ->
            listener.onRequestSequenceCompleted(request, frameNumber)
        }
    }

    override fun onCaptureSequenceAborted(
        captureSession: CameraCaptureSession,
        captureSequenceId: Int
    ) {
        check(sequenceNumber == captureSequenceId) {
            "Abort was invoked on $sequenceNumber, but the sequence was not fully submitted!"
        }

        // Remove this request from the set of requests that are currently tracked.
        synchronized(inFlightRequests) {
            inFlightRequests.remove(this)
        }

        invokeOnRequests { request, _, listener ->
            listener.onRequestSequenceAborted(request)
        }
    }

    private fun readRequestNumber(request: CaptureRequest): RequestNumber =
        checkNotNull(request.tag as RequestNumber)

    private fun readRequest(requestNumber: RequestNumber): RequestInfo {
        return checkNotNull(requests[requestNumber]) {
            "Unable to find the request for $requestNumber!"
        }
    }

    private inline fun invokeOnRequests(
        crossinline fn: (RequestMetadata, Int, Request.Listener) -> Any
    ) {

        // Always invoke the internal listener first on all of the internal listeners for the
        // entire sequence before invoking the listeners specified in the specific requests
        for (i in captureRequests.indices) {
            val requestNumber = readRequestNumber(captureRequests[i])
            val request = checkNotNull(requests[requestNumber])

            for (listenerIndex in internalListeners.indices) {
                fn(request, i, internalListeners[listenerIndex])
            }
        }

        for (i in captureRequests.indices) {
            val requestNumber = readRequestNumber(captureRequests[i])
            val request = checkNotNull(requests[requestNumber])

            for (listenerIndex in request.request.listeners.indices) {
                fn(request, i, request.request.listeners[listenerIndex])
            }
        }
    }

    private inline fun invokeOnRequest(
        request: RequestInfo,
        crossinline fn: (Request.Listener) -> Any
    ) {
        // Always invoke the internal listener first so that internal sate can be updated before
        // other listeners ask for it.
        for (i in internalListeners.indices) {
            fn(internalListeners[i])
        }

        // Invoke the listeners that were defined on this request.
        for (i in request.request.listeners.indices) {
            fn(request.request.listeners[i])
        }
    }

    override fun toString(): String = "CaptureSequence-$debugId"
}