// Copyright (C) 2019 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 "PipeOptionsConverter.h"

#include "aidl/android/automotive/computepipe/runner/PipeInputConfigInputType.h"

namespace android {
namespace automotive {
namespace computepipe {
namespace runner {
namespace client_interface {
namespace aidl_client {

using ::aidl::android::automotive::computepipe::runner::PipeDescriptor;
using ::aidl::android::automotive::computepipe::runner::PipeInputConfig;
using ::aidl::android::automotive::computepipe::runner::PipeInputConfigCameraDesc;
using ::aidl::android::automotive::computepipe::runner::PipeInputConfigCameraType;
using ::aidl::android::automotive::computepipe::runner::PipeInputConfigFormatType;
using ::aidl::android::automotive::computepipe::runner::PipeInputConfigImageFileType;
using ::aidl::android::automotive::computepipe::runner::PipeInputConfigInputSourceDesc;
using ::aidl::android::automotive::computepipe::runner::PipeInputConfigInputType;
using ::aidl::android::automotive::computepipe::runner::PipeInputConfigVideoFileType;
using ::aidl::android::automotive::computepipe::runner::PipeOffloadConfig;
using ::aidl::android::automotive::computepipe::runner::PipeOffloadConfigOffloadType;
using ::aidl::android::automotive::computepipe::runner::PipeOutputConfig;
using ::aidl::android::automotive::computepipe::runner::PipeOutputConfigPacketType;
using ::aidl::android::automotive::computepipe::runner::PipeTerminationConfig;
using ::aidl::android::automotive::computepipe::runner::PipeTerminationConfigTerminationType;

namespace {

PipeInputConfigInputType ConvertInputType(proto::InputStreamConfig::InputType type) {
    switch (type) {
        case proto::InputStreamConfig::CAMERA:
            return PipeInputConfigInputType::CAMERA;
        case proto::InputStreamConfig::VIDEO_FILE:
            return PipeInputConfigInputType::VIDEO_FILE;
        case proto::InputStreamConfig::IMAGE_FILES:
            return PipeInputConfigInputType::IMAGE_FILES;
    }
}

PipeInputConfigCameraType ConvertCameraType(proto::CameraConfig::CameraType type) {
    switch (type) {
        case proto::CameraConfig::DRIVER_VIEW_CAMERA:
            return PipeInputConfigCameraType::DRIVER_VIEW_CAMERA;
        case proto::CameraConfig::OCCUPANT_VIEW_CAMERA:
            return PipeInputConfigCameraType::OCCUPANT_VIEW_CAMERA;
        case proto::CameraConfig::EXTERNAL_CAMERA:
            return PipeInputConfigCameraType::EXTERNAL_CAMERA;
        case proto::CameraConfig::SURROUND_VIEW_CAMERA:
            return PipeInputConfigCameraType::SURROUND_VIEW_CAMERA;
    }
}

PipeInputConfigImageFileType ConvertImageFileType(proto::ImageFileConfig::ImageFileType type) {
    switch (type) {
        case proto::ImageFileConfig::JPEG:
            return PipeInputConfigImageFileType::JPEG;
        case proto::ImageFileConfig::PNG:
            return PipeInputConfigImageFileType::PNG;
    }
}

PipeInputConfigVideoFileType ConvertVideoFileType(proto::VideoFileConfig::VideoFileType type) {
    switch (type) {
        case proto::VideoFileConfig::MPEG:
            return PipeInputConfigVideoFileType::MPEG;
    }
}

PipeInputConfigFormatType ConvertInputFormat(proto::InputStreamConfig::FormatType type) {
    switch (type) {
        case proto::InputStreamConfig::RGB:
            return PipeInputConfigFormatType::RGB;
        case proto::InputStreamConfig::NIR:
            return PipeInputConfigFormatType::NIR;
        case proto::InputStreamConfig::NIR_DEPTH:
            return PipeInputConfigFormatType::NIR_DEPTH;
    }
}

PipeOffloadConfigOffloadType ConvertOffloadType(proto::OffloadOption::OffloadType type) {
    switch (type) {
        case proto::OffloadOption::CPU:
            return PipeOffloadConfigOffloadType::CPU;
        case proto::OffloadOption::GPU:
            return PipeOffloadConfigOffloadType::GPU;
        case proto::OffloadOption::NEURAL_ENGINE:
            return PipeOffloadConfigOffloadType::NEURAL_ENGINE;
        case proto::OffloadOption::CV_ENGINE:
            return PipeOffloadConfigOffloadType::CV_ENGINE;
    }
}

PipeOutputConfigPacketType ConvertOutputType(proto::PacketType type) {
    switch (type) {
        case proto::PacketType::SEMANTIC_DATA:
            return PipeOutputConfigPacketType::SEMANTIC_DATA;
        case proto::PacketType::PIXEL_DATA:
            return PipeOutputConfigPacketType::PIXEL_DATA;
        case proto::PacketType::PIXEL_ZERO_COPY_DATA:
            return PipeOutputConfigPacketType::PIXEL_ZERO_COPY_DATA;
    }
}

PipeTerminationConfigTerminationType ConvertTerminationType(
    proto::TerminationOption::TerminationType type) {
    switch (type) {
        case proto::TerminationOption::CLIENT_STOP:
            return PipeTerminationConfigTerminationType::CLIENT_STOP;
        case proto::TerminationOption::MIN_PACKET_COUNT:
            return PipeTerminationConfigTerminationType::MIN_PACKET_COUNT;
        case proto::TerminationOption::MAX_RUN_TIME:
            return PipeTerminationConfigTerminationType::MAX_RUN_TIME;
        case proto::TerminationOption::EVENT:
            return PipeTerminationConfigTerminationType::EVENT;
    }
}

PipeInputConfig ConvertInputConfigProto(const proto::InputConfig& proto) {
    PipeInputConfig aidlConfig;

    for (const auto& inputStreamConfig : proto.input_stream()) {
        PipeInputConfigInputSourceDesc aidlInputDesc;
        aidlInputDesc.type = ConvertInputType(inputStreamConfig.type());
        aidlInputDesc.format = ConvertInputFormat(inputStreamConfig.format());
        aidlInputDesc.width = inputStreamConfig.width();
        aidlInputDesc.height = inputStreamConfig.height();
        aidlInputDesc.stride = inputStreamConfig.stride();
        aidlInputDesc.camDesc.camId = inputStreamConfig.cam_config().cam_id();
        aidlInputDesc.camDesc.type =
                ConvertCameraType(inputStreamConfig.cam_config().camera_type());
        aidlInputDesc.imageDesc.fileType =
            ConvertImageFileType(inputStreamConfig.image_config().file_type());
        aidlInputDesc.imageDesc.filePath = inputStreamConfig.image_config().image_dir();
        aidlInputDesc.videoDesc.fileType =
            ConvertVideoFileType(inputStreamConfig.video_config().file_type());
        aidlInputDesc.videoDesc.filePath = inputStreamConfig.video_config().file_path();
        aidlConfig.inputSources.emplace_back(aidlInputDesc);
    }
    aidlConfig.configId = proto.config_id();

    return aidlConfig;
}

PipeOffloadConfig ConvertOffloadConfigProto(const proto::OffloadConfig& proto) {
    PipeOffloadConfig aidlConfig;

    for (int i = 0; i < proto.options().offload_types_size(); i++) {
        auto offloadType =
            static_cast<proto::OffloadOption_OffloadType>(proto.options().offload_types()[i]);
        PipeOffloadConfigOffloadType aidlType = ConvertOffloadType(offloadType);
        aidlConfig.desc.type.emplace_back(aidlType);
        aidlConfig.desc.isVirtual.emplace_back(proto.options().is_virtual()[i]);
    }

    aidlConfig.configId = proto.config_id();
    return aidlConfig;
}

PipeOutputConfig ConvertOutputConfigProto(const proto::OutputConfig& proto) {
    PipeOutputConfig aidlConfig;
    aidlConfig.output.name = proto.stream_name();
    aidlConfig.output.type = ConvertOutputType(proto.type());
    aidlConfig.outputId = proto.stream_id();
    return aidlConfig;
}

PipeTerminationConfig ConvertTerminationConfigProto(const proto::TerminationConfig& proto) {
    PipeTerminationConfig aidlConfig;
    aidlConfig.desc.type = ConvertTerminationType(proto.options().type());
    aidlConfig.desc.qualifier = proto.options().qualifier();
    aidlConfig.configId = proto.config_id();
    return aidlConfig;
}

}  // namespace

PipeDescriptor OptionsToPipeDescriptor(const proto::Options& options) {
    PipeDescriptor desc;
    for (int i = 0; i < options.input_configs_size(); i++) {
        PipeInputConfig inputConfig = ConvertInputConfigProto(options.input_configs()[i]);
        desc.inputConfig.emplace_back(inputConfig);
    }

    for (int i = 0; i < options.offload_configs_size(); i++) {
        PipeOffloadConfig offloadConfig = ConvertOffloadConfigProto(options.offload_configs()[i]);
        desc.offloadConfig.emplace_back(offloadConfig);
    }

    for (int i = 0; i < options.termination_configs_size(); i++) {
        PipeTerminationConfig terminationConfig =
            ConvertTerminationConfigProto(options.termination_configs()[i]);
        desc.terminationConfig.emplace_back(terminationConfig);
    }

    for (int i = 0; i < options.output_configs_size(); i++) {
        PipeOutputConfig outputConfig = ConvertOutputConfigProto(options.output_configs()[i]);
        desc.outputConfig.emplace_back(outputConfig);
    }
    return desc;
}

}  // namespace aidl_client
}  // namespace client_interface
}  // namespace runner
}  // namespace computepipe
}  // namespace automotive
}  // namespace android