/*
 * Copyright (C) 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 <libradiocompat/RadioNetwork.h>

#include "commonStructs.h"
#include "debug.h"
#include "structs.h"
#include "utils.h"

#include "collections.h"

#define RADIO_MODULE "Network"

namespace android::hardware::radio::compat {

using ::aidl::android::hardware::radio::AccessNetwork;
using ::ndk::ScopedAStatus;
namespace aidl = ::aidl::android::hardware::radio::network;
constexpr auto ok = &ScopedAStatus::ok;

std::shared_ptr<aidl::IRadioNetworkResponse> RadioNetwork::respond() {
    return mCallbackManager->response().networkCb();
}

ScopedAStatus RadioNetwork::getAllowedNetworkTypesBitmap(int32_t serial) {
    LOG_CALL << serial;
    if (mHal1_6) {
        mHal1_6->getAllowedNetworkTypesBitmap(serial);
    } else {
        mHal1_5->getPreferredNetworkType(serial);
    }
    return ok();
}

ScopedAStatus RadioNetwork::getAvailableBandModes(int32_t serial) {
    LOG_CALL << serial;
    mHal1_5->getAvailableBandModes(serial);
    return ok();
}

ScopedAStatus RadioNetwork::getAvailableNetworks(int32_t serial) {
    LOG_CALL << serial;
    mHal1_5->getAvailableNetworks(serial);
    return ok();
}

ScopedAStatus RadioNetwork::getBarringInfo(int32_t serial) {
    LOG_CALL << serial;
    mHal1_5->getBarringInfo(serial);
    return ok();
}

ScopedAStatus RadioNetwork::getCdmaRoamingPreference(int32_t serial) {
    LOG_CALL << serial;
    mHal1_5->getCdmaRoamingPreference(serial);
    return ok();
}

ScopedAStatus RadioNetwork::getCellInfoList(int32_t serial) {
    LOG_CALL << serial;
    if (mHal1_6) {
        mHal1_6->getCellInfoList_1_6(serial);
    } else {
        mHal1_5->getCellInfoList(serial);
    }
    return ok();
}

ScopedAStatus RadioNetwork::getDataRegistrationState(int32_t serial) {
    LOG_CALL << serial;
    if (mHal1_6) {
        mHal1_6->getDataRegistrationState_1_6(serial);
    } else {
        mHal1_5->getDataRegistrationState_1_5(serial);
    }
    return ok();
}

ScopedAStatus RadioNetwork::getImsRegistrationState(int32_t serial) {
    LOG_CALL << serial;
    mHal1_5->getImsRegistrationState(serial);
    return ok();
}

ScopedAStatus RadioNetwork::getNetworkSelectionMode(int32_t serial) {
    LOG_CALL << serial;
    mHal1_5->getNetworkSelectionMode(serial);
    return ok();
}

ScopedAStatus RadioNetwork::getOperator(int32_t serial) {
    LOG_CALL << serial;
    mHal1_5->getOperator(serial);
    return ok();
}

ScopedAStatus RadioNetwork::getSignalStrength(int32_t serial) {
    LOG_CALL << serial;
    if (mHal1_6) {
        mHal1_6->getSignalStrength_1_6(serial);
    } else {
        mHal1_5->getSignalStrength_1_4(serial);
    }
    return ok();
}

ScopedAStatus RadioNetwork::getSystemSelectionChannels(int32_t serial) {
    LOG_CALL << serial;
    if (mHal1_6) {
        mHal1_6->getSystemSelectionChannels(serial);
    } else {
        respond()->getSystemSelectionChannelsResponse(notSupported(serial), {});
    }
    return ok();
}

ScopedAStatus RadioNetwork::getVoiceRadioTechnology(int32_t serial) {
    LOG_CALL << serial;
    mHal1_5->getVoiceRadioTechnology(serial);
    return ok();
}

ScopedAStatus RadioNetwork::getVoiceRegistrationState(int32_t serial) {
    LOG_CALL << serial;
    if (mHal1_6) {
        mHal1_6->getVoiceRegistrationState_1_6(serial);
    } else {
        mHal1_5->getVoiceRegistrationState_1_5(serial);
    }
    return ok();
}

ScopedAStatus RadioNetwork::isNrDualConnectivityEnabled(int32_t serial) {
    LOG_CALL << serial;
    if (mHal1_6) {
        mHal1_6->isNrDualConnectivityEnabled(serial);
    } else {
        respond()->isNrDualConnectivityEnabledResponse(notSupported(serial), false);
    }
    return ok();
}

ScopedAStatus RadioNetwork::responseAcknowledgement() {
    LOG_CALL;
    mHal1_5->responseAcknowledgement();
    return ok();
}

ScopedAStatus RadioNetwork::setAllowedNetworkTypesBitmap(int32_t serial, int32_t ntype) {
    LOG_CALL << serial;
    const auto raf = toHidlBitfield<V1_4::RadioAccessFamily>(ntype);
    if (mHal1_6) {
        mHal1_6->setAllowedNetworkTypesBitmap(serial, raf);
    } else {
        mHal1_5->setPreferredNetworkType(serial, getNetworkTypeFromRaf(raf));
    }
    return ok();
}

ScopedAStatus RadioNetwork::setBandMode(int32_t serial, aidl::RadioBandMode mode) {
    LOG_CALL << serial;
    mHal1_5->setBandMode(serial, V1_0::RadioBandMode(mode));
    return ok();
}

ScopedAStatus RadioNetwork::setBarringPassword(int32_t serial, const std::string& facility,
                                               const std::string& oldPw, const std::string& newPw) {
    LOG_CALL << serial;
    mHal1_5->setBarringPassword(serial, facility, oldPw, newPw);
    return ok();
}

ScopedAStatus RadioNetwork::setCdmaRoamingPreference(int32_t serial, aidl::CdmaRoamingType type) {
    LOG_CALL << serial;
    mHal1_5->setCdmaRoamingPreference(serial, V1_0::CdmaRoamingType(type));
    return ok();
}

ScopedAStatus RadioNetwork::setCellInfoListRate(int32_t serial, int32_t rate) {
    LOG_CALL << serial;
    mHal1_5->setCellInfoListRate(serial, rate);
    return ok();
}

ScopedAStatus RadioNetwork::setIndicationFilter(int32_t serial, int32_t indFilter) {
    LOG_CALL << serial;
    mHal1_5->setIndicationFilter_1_5(serial, toHidlBitfield<V1_5::IndicationFilter>(indFilter));
    return ok();
}

ScopedAStatus RadioNetwork::setLinkCapacityReportingCriteria(  //
        int32_t serial, int32_t hysteresisMs, int32_t hysteresisDlKbps, int32_t hysteresisUlKbps,
        const std::vector<int32_t>& thrDownlinkKbps, const std::vector<int32_t>& thrUplinkKbps,
        AccessNetwork accessNetwork) {
    LOG_CALL << serial;
    mHal1_5->setLinkCapacityReportingCriteria_1_5(  //
            serial, hysteresisMs, hysteresisDlKbps, hysteresisUlKbps, thrDownlinkKbps,
            thrUplinkKbps, V1_5::AccessNetwork(accessNetwork));
    return ok();
}

ScopedAStatus RadioNetwork::setLocationUpdates(int32_t serial, bool enable) {
    LOG_CALL << serial;
    mHal1_5->setLocationUpdates(serial, enable);
    return ok();
}

ScopedAStatus RadioNetwork::setNetworkSelectionModeAutomatic(int32_t serial) {
    LOG_CALL << serial;
    mHal1_5->setNetworkSelectionModeAutomatic(serial);
    return ok();
}

ScopedAStatus RadioNetwork::setNetworkSelectionModeManual(  //
        int32_t serial, const std::string& opNumeric, AccessNetwork ran) {
    LOG_CALL << serial;
    mHal1_5->setNetworkSelectionModeManual_1_5(serial, opNumeric, toRadioAccessNetworks(ran));
    return ok();
}

ScopedAStatus RadioNetwork::setNrDualConnectivityState(int32_t serial,
                                                       aidl::NrDualConnectivityState st) {
    LOG_CALL << serial;
    if (mHal1_6) {
        mHal1_6->setNrDualConnectivityState(serial, V1_6::NrDualConnectivityState(st));
    } else {
        respond()->setNrDualConnectivityStateResponse(notSupported(serial));
    }
    return ok();
}

ScopedAStatus RadioNetwork::setResponseFunctions(
        const std::shared_ptr<aidl::IRadioNetworkResponse>& response,
        const std::shared_ptr<aidl::IRadioNetworkIndication>& indication) {
    LOG_CALL << response << ' ' << indication;
    mCallbackManager->setResponseFunctions(response, indication);
    return ok();
}

ScopedAStatus RadioNetwork::setSignalStrengthReportingCriteria(
        int32_t serial, const std::vector<aidl::SignalThresholdInfo>& infos) {
    LOG_CALL << serial;
    if (infos.size() == 0) {
        LOG(ERROR) << "Threshold info array is empty - dropping setSignalStrengthReportingCriteria";
        return ok();
    }
    if (infos.size() > 1) {
        LOG(WARNING) << "Multi-element reporting criteria are not supported with HIDL HAL";
    }
    if (infos[0].signalMeasurement == aidl::SignalThresholdInfo::SIGNAL_MEASUREMENT_TYPE_ECNO) {
        LOG(WARNING) << "SIGNAL_MEASUREMENT_TYPE_ECNO are not supported with HIDL HAL";
        respond()->setSignalStrengthReportingCriteriaResponse(notSupported(serial));
        return ok();
    }
    mHal1_5->setSignalStrengthReportingCriteria_1_5(serial, toHidl(infos[0]),
                                                    V1_5::AccessNetwork(infos[0].ran));
    return ok();
}

ScopedAStatus RadioNetwork::setSuppServiceNotifications(int32_t serial, bool enable) {
    LOG_CALL << serial;
    mHal1_5->setSuppServiceNotifications(serial, enable);
    return ok();
}

ScopedAStatus RadioNetwork::setSystemSelectionChannels(  //
        int32_t serial, bool specifyCh, const std::vector<aidl::RadioAccessSpecifier>& specifiers) {
    LOG_CALL << serial;
    mHal1_5->setSystemSelectionChannels_1_5(serial, specifyCh, toHidl(specifiers));
    return ok();
}

ScopedAStatus RadioNetwork::startNetworkScan(int32_t serial, const aidl::NetworkScanRequest& req) {
    LOG_CALL << serial;
    mHal1_5->startNetworkScan_1_5(serial, toHidl(req));
    return ok();
}

ScopedAStatus RadioNetwork::stopNetworkScan(int32_t serial) {
    LOG_CALL << serial;
    mHal1_5->stopNetworkScan(serial);
    return ok();
}

ScopedAStatus RadioNetwork::supplyNetworkDepersonalization(int32_t ser, const std::string& nPin) {
    LOG_CALL << ser;
    mHal1_5->supplyNetworkDepersonalization(ser, nPin);
    return ok();
}

ScopedAStatus RadioNetwork::setUsageSetting(int32_t serial, aidl::UsageSetting) {
    LOG_CALL << serial;
    LOG(ERROR) << "setUsageSetting is unsupported by HIDL HALs";
    respond()->setUsageSettingResponse(notSupported(serial));
    return ok();
}

ScopedAStatus RadioNetwork::getUsageSetting(int32_t serial) {
    LOG_CALL << serial;
    LOG(ERROR) << "getUsageSetting is unsupported by HIDL HALs";
    respond()->getUsageSettingResponse(notSupported(serial), {});  // {} = neither voice nor data
    return ok();
}

ScopedAStatus RadioNetwork::setEmergencyMode(int32_t serial, aidl::EmergencyMode) {
    LOG_CALL << serial;
    LOG(ERROR) << " setEmergencyMode is unsupported by HIDL HALs";
    respond()->setEmergencyModeResponse(notSupported(serial), {});
    return ok();
}

ScopedAStatus RadioNetwork::triggerEmergencyNetworkScan(int32_t serial,
        const aidl::EmergencyNetworkScanTrigger&) {
    LOG_CALL << serial;
    LOG(ERROR) << " triggerEmergencyNetworkScan is unsupported by HIDL HALs";
    respond()->triggerEmergencyNetworkScanResponse(notSupported(serial));
    return ok();
}

ScopedAStatus RadioNetwork::cancelEmergencyNetworkScan(int32_t serial, bool) {
    LOG_CALL << serial;
    LOG(ERROR) << " cancelEmergencyNetworkScan is unsupported by HIDL HALs";
    respond()->cancelEmergencyNetworkScanResponse(notSupported(serial));
    return ok();
}

ScopedAStatus RadioNetwork::exitEmergencyMode(int32_t serial) {
    LOG_CALL << serial;
    LOG(ERROR) << " exitEmergencyMode is unsupported by HIDL HALs";
    respond()->exitEmergencyModeResponse(notSupported(serial));
    return ok();
}

ScopedAStatus RadioNetwork::setNullCipherAndIntegrityEnabled(int32_t serial, bool) {
    LOG_CALL << serial;
    LOG(ERROR) << " setNullCipherAndIntegrityEnabled is unsupported by HIDL HALs";
    respond()->setNullCipherAndIntegrityEnabledResponse(notSupported(serial));
    return ok();
}

ScopedAStatus RadioNetwork::isNullCipherAndIntegrityEnabled(int32_t serial) {
    LOG_CALL << serial;
    LOG(ERROR) << " isNullCipherAndIntegrityEnabled is unsupported by HIDL HALs";
    respond()->isNullCipherAndIntegrityEnabledResponse(notSupported(serial), true);
    return ok();
}

ScopedAStatus RadioNetwork::isN1ModeEnabled(int32_t serial) {
    LOG_CALL << serial;
    LOG(ERROR) << " isN1ModeEnabled is unsupported by HIDL HALs";
    respond()->isN1ModeEnabledResponse(notSupported(serial), false);
    return ok();
}

ScopedAStatus RadioNetwork::setN1ModeEnabled(int32_t serial, bool /*enable*/) {
    LOG_CALL << serial;
    LOG(ERROR) << " setN1ModeEnabled is unsupported by HIDL HALs";
    respond()->setN1ModeEnabledResponse(notSupported(serial));
    return ok();
}

ScopedAStatus RadioNetwork::isCellularIdentifierTransparencyEnabled(int32_t serial) {
    LOG_CALL << serial;
    LOG(ERROR) << " isCellularIdentifierTransparencyEnabled is unsupported by HIDL HALs";
    respond()->isCellularIdentifierTransparencyEnabledResponse(notSupported(serial), false);
    return ok();
}

ScopedAStatus RadioNetwork::setCellularIdentifierTransparencyEnabled(int32_t serial,
                                                                     bool /*enabled*/) {
    LOG_CALL << serial;
    LOG(ERROR) << " setCellularIdentifierTransparencyEnabled is unsupported by HIDL HALs";
    respond()->setCellularIdentifierTransparencyEnabledResponse(notSupported(serial));
    return ok();
}

ScopedAStatus RadioNetwork::isSecurityAlgorithmsUpdatedEnabled(int32_t serial) {
    LOG_CALL << serial;
    LOG(ERROR) << " isSecurityAlgorithmsUpdatedEnabled is unsupported by HIDL HALs";
    respond()->isSecurityAlgorithmsUpdatedEnabledResponse(notSupported(serial), false);
    return ok();
}

ScopedAStatus RadioNetwork::setSecurityAlgorithmsUpdatedEnabled(int32_t serial, bool /*enable*/) {
    LOG_CALL << serial;
    LOG(ERROR) << " setSecurityAlgorithmsUpdatedEnabled is unsupported by HIDL HALs";
    respond()->setSecurityAlgorithmsUpdatedEnabledResponse(notSupported(serial));
    return ok();
}

}  // namespace android::hardware::radio::compat