/*
 * Copyright 2021 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.
 */

#include "StreamHandler.h"

#include <android-base/chrono_utils.h>
#include <android-base/logging.h>
#include <cutils/native_handle.h>

#include <cstring>

using namespace ::android::hardware::automotive::evs::V1_1;

using ::android::sp;
using ::android::hardware::hidl_handle;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::automotive::evs::V1_0::EvsResult;
using ::android::hardware::automotive::evs::V1_1::IEvsDisplay;

using EvsDisplayState = ::android::hardware::automotive::evs::V1_0::DisplayState;
using BufferDesc_1_0 = ::android::hardware::automotive::evs::V1_0::BufferDesc;
using BufferDesc_1_1 = ::android::hardware::automotive::evs::V1_1::BufferDesc;

namespace android {
namespace automotive {
namespace evs {

StreamHandler::StreamHandler(sp<IEvsCamera>& camera, EvsServiceCallback* callback,
                             int maxNumFramesInFlight) :
      mEvsCamera(camera), mCallback(callback), mMaxNumFramesInFlight(maxNumFramesInFlight) {
    if (camera == nullptr) {
        LOG(ERROR) << "IEvsCamera is invalid.";
    } else {
        // We rely on the camera having at least two buffers available since we'll hold one and
        // expect the camera to be able to capture a new image in the background.
        auto status = camera->setMaxFramesInFlight(maxNumFramesInFlight);
        if (!status.isOk()) {
            LOG(WARNING) << "Failed to adjust the maximum number of frames in flight.";
        }
    }
}

/*
 * Shuts down a stream handler
 */
StreamHandler::~StreamHandler() {
    shutdown();
}

/*
 * Stops an active stream and releases the camera device in use
 */
void StreamHandler::shutdown() {
    // Make sure we're not still streaming
    blockingStopStream();

    // At this point, the receiver thread is no longer running, so we can safely drop
    // our remote object references so they can be freed
    mEvsCamera = nullptr;
}

/*
 * Requests EVS to start a video stream
 */
bool StreamHandler::startStream() {
    std::lock_guard<std::mutex> lock(mLock);
    if (!mRunning) {
        auto result = mEvsCamera->startVideoStream(this);
        if (!result.isOk() or result != EvsResult::OK) {
            LOG(ERROR) << "StreamHandler failed to start a video stream.";
            return false;
        }

        // Marks ourselves as running
        mRunning = true;
    }

    return true;
}

/*
 * Requests to stop a video stream
 */
bool StreamHandler::asyncStopStream() {
    bool success = true;

    // This will result in STREAM_STOPPED event; the client may want to wait
    // this event to confirm the closure.
    {
        std::lock_guard<std::mutex> lock(mLock);
        auto it = mReceivedBuffers.begin();
        while (it != mReceivedBuffers.end()) {
            // Packages a returned buffer and sends it back to the camera
            hidl_vec<BufferDesc_1_1> frames;
            frames.resize(1);
            frames[0] = *it;
            auto status = mEvsCamera->doneWithFrame_1_1(frames);
            if (!status.isOk()) {
                LOG(WARNING) << "Failed to return a frame to EVS service; "
                             << "this may leak the memory.";
                success = false;
            }

            it = mReceivedBuffers.erase(it);
        }
    }

    auto status = mEvsCamera->stopVideoStream();
    if (!status.isOk()) {
        LOG(WARNING) << "stopVideoStream() failed but ignored.";
        success = false;
    }

    return success;
}

/*
 * Requests to stop a video stream and waits for a confirmation
 */
void StreamHandler::blockingStopStream() {
    if (!asyncStopStream()) {
        // EVS service may die so no stream-stop event occurs.
        std::lock_guard<std::mutex> lock(mLock);
        mRunning = false;
        return;
    }

    // Waits until the stream has actually stopped
    std::unique_lock<std::mutex> lock(mLock);
    while (mRunning) {
        if (!mCondition.wait_for(lock, 1s, [this]() { return !mRunning; })) {
            LOG(WARNING) << "STREAM_STOPPED event timer expired.  EVS service may die.";
            break;
        }
    }
}

bool StreamHandler::isRunning() {
    std::lock_guard<std::mutex> lock(mLock);
    return mRunning;
}

void StreamHandler::doneWithFrame(const BufferDesc_1_1& buffer) {
    {
        std::lock_guard<std::mutex> lock(mLock);
        auto it = mReceivedBuffers.begin();
        while (it != mReceivedBuffers.end()) {
            if (it->bufferId == buffer.bufferId) {
                mReceivedBuffers.erase(it);
                break;
            }
        }
    }

    // Packages a returned buffer and sends it back to the camera
    hidl_vec<BufferDesc_1_1> frames;
    frames.resize(1);
    frames[0] = buffer;
    auto status = mEvsCamera->doneWithFrame_1_1(frames);
    if (!status.isOk()) {
        LOG(ERROR) << "Failed to return a frame to EVS service; this may leak the memory.";
    }
}

Return<void> StreamHandler::deliverFrame(const BufferDesc_1_0& buffer) {
    LOG(WARNING) << "Ignores a frame delivered from v1.0 EVS service.";
    auto status = mEvsCamera->doneWithFrame(buffer);
    if (!status.isOk()) {
        LOG(ERROR) << "Failed to return a frame to EVS service; this may leak the memory.";
    }
    return {};
}

Return<void> StreamHandler::deliverFrame_1_1(const hidl_vec<BufferDesc_1_1>& buffers) {
    LOG(DEBUG) << "Received frames from the camera, bufferId = " << buffers[0].bufferId;

    // Takes the lock to protect our frameDesc slots and running state variable
    BufferDesc_1_1 frameDesc = buffers[0];
    if (frameDesc.buffer.nativeHandle.getNativeHandle() == nullptr) {
        // Signals that the last frameDesc has been received and the stream is stopped
        LOG(WARNING) << "Invalid null frameDesc (id: 0x" << std::hex << frameDesc.bufferId
                     << ") is ignored";

        return {};
    }

    size_t numBuffersInUse;
    {
        std::lock_guard<std::mutex> lock(mLock);
        numBuffersInUse = mReceivedBuffers.size();
    }

    if (numBuffersInUse > mMaxNumFramesInFlight) {
        // We're holding more than what allowed; returns this buffer
        // immediately.
        doneWithFrame(frameDesc);
    } else {
        {
            std::lock_guard<std::mutex> lock(mLock);
            // Records a new frameDesc and forwards to clients
            mReceivedBuffers.emplace_back(frameDesc);
            LOG(DEBUG) << "Got buffer " << frameDesc.bufferId
                       << ", total = " << mReceivedBuffers.size();

            // Notify anybody who cares that things have changed
            mCondition.notify_all();
        }

        // Forwards a new frame
        mCallback->onNewFrame(frameDesc);
    }

    return {};
}

Return<void> StreamHandler::notify(const EvsEventDesc& event) {
    switch (event.aType) {
        case EvsEventType::STREAM_STOPPED: {
            {
                std::lock_guard<std::mutex> lock(mLock);
                // Signal that the last frame has been received and the stream is stopped
                mRunning = false;
            }
            LOG(DEBUG) << "Received a STREAM_STOPPED event";
            break;
        }
        case EvsEventType::PARAMETER_CHANGED:
            LOG(DEBUG) << "Camera parameter 0x" << std::hex << event.payload[0] << " is set to 0x"
                       << std::hex << event.payload[1];
            break;
        // Below events are ignored in reference implementation.
        case EvsEventType::STREAM_STARTED:
            [[fallthrough]];
        case EvsEventType::FRAME_DROPPED:
            [[fallthrough]];
        case EvsEventType::TIMEOUT:
            LOG(INFO) << "Event 0x" << std::hex << static_cast<int32_t>(event.aType)
                      << " is received but ignored";
            break;
        default:
            LOG(ERROR) << "Unknown event id 0x" << std::hex << static_cast<int32_t>(event.aType);
            break;
    }

    mCallback->onNewEvent(event);

    return {};
}

}  // namespace evs
}  // namespace automotive
}  // namespace android