/*
 * Copyright (C) 2025 Huawei Device Co., Ltd.
 * 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 "usb_settings_datashare.h"

#include "hilog_wrapper.h"
#include "datashare_helper.h"
#include "datashare_predicates.h"
#include "iservice_registry.h"
#include "uri.h"
#include "singleton.h"

namespace OHOS {
namespace USB {
namespace {
constexpr const char *SETTINGS_DATASHARE_URI =
    "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
const std::string SETTINGS_DATASHARE_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
constexpr const char *SETTINGS_DATA_COLUMN_KEYWORD = "KEYWORD";
constexpr const char *SETTINGS_DATA_COLUMN_VALUE = "VALUE";
}
 
UsbSettingDataShare::UsbSettingDataShare()
{
    datashareHelper_ = CreateDataShareHelper(USB_SYSTEM_ABILITY_ID);
}
 
UsbSettingDataShare::~UsbSettingDataShare()
{
    if (datashareHelper_ != nullptr) {
        USB_HILOGI(MODULE_USB_SERVICE, "datashareHelper_ is here Release!");
        datashareHelper_->Release();
    }
}

std::shared_ptr<DataShare::DataShareHelper> UsbSettingDataShare::CreateDataShareHelper(int systemAbilityId)
{
    USB_HILOGI(MODULE_USB_SERVICE, "CreateDataShareHelper start!");
    sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
    if (saManager == nullptr) {
        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: GetSystemAbilityManager failed!", __func__);
        return nullptr;
    }
    sptr<IRemoteObject> remote = saManager->GetSystemAbility(systemAbilityId);
    if (remote == nullptr) {
        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: GetSystemAbility Service Failed!", __func__);
        return nullptr;
    }
    USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: systemAbilityId = %{public}d", __func__, systemAbilityId);
    auto [ret, helper] = DataShare::DataShareHelper::Create(remote, SETTINGS_DATASHARE_URI, SETTINGS_DATASHARE_EXT_URI);
    if (ret == DataShare::E_OK) {
        return helper;
    } else if (ret == DataShare::E_DATA_SHARE_NOT_READY) {
        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: data is not ready!", __func__);
        return nullptr;
    } else {
        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: create datashare failed, ret = %{public}d.", __func__, ret);
        return nullptr;
    }
}
 
bool UsbSettingDataShare::Query(Uri &uri, const std::string &key, std::string &value)
{
    USB_HILOGI(MODULE_USB_SERVICE, "start Query key = %{public}s", key.c_str());
    if (datashareHelper_ == nullptr) {
        USB_HILOGE(MODULE_USB_SERVICE, "query error, datashareHelper_ is nullptr");
        return false;
    }
 
    std::vector<std::string> columns;
    DataShare::DataSharePredicates predicates;
    predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
    auto result = datashareHelper_->Query(uri, predicates, columns);
    if (result == nullptr) {
        USB_HILOGE(MODULE_USB_SERVICE, "query error, result is nullptr");
        return false;
    }
 
    if (result->GoToFirstRow() != DataShare::E_OK) {
        USB_HILOGE(MODULE_USB_SERVICE, "query error, go to first row error");
        result->Close();
        return false;
    }
 
    int columnIndex = 0;
    result->GetColumnIndex(SETTINGS_DATA_COLUMN_VALUE, columnIndex);
    result->GetString(columnIndex, value);
    result->Close();
    USB_HILOGI(MODULE_USB_SERVICE, "SettingUtils: query success");
    return true;
}

bool UsbSettingDataShare::Insert(Uri uri, const std::string &key, std::string &value)
{
    USB_HILOGI(MODULE_USB_SERVICE, "start Insert key = %{public}s", key.c_str());
    if (datashareHelper_ == nullptr) {
        USB_HILOGE(MODULE_USB_SERVICE, "query error, datashareHelper_ is nullptr");
        return false;
    }
    DataShare::DataShareValuesBucket valuesBucket;
    DataShare::DataShareValueObject keyObj(key);
    DataShare::DataShareValueObject valueObj(value);
    valuesBucket.Put(SETTINGS_DATA_COLUMN_KEYWORD, keyObj);
    valuesBucket.Put(SETTINGS_DATA_COLUMN_VALUE, valueObj);
    int32_t result = datashareHelper_->Insert(uri, valuesBucket);
    if (result == RDB_INVALID_VALUE) {
        datashareHelper_->Release();
        return false;
    }
    USB_HILOGI(MODULE_USB_SERVICE, "UsbSettingDataShare: insert success");
    datashareHelper_->NotifyChange(uri);
    datashareHelper_->Release();
    return true;
}

bool UsbSettingDataShare::Update(Uri uri, const std::string &key, std::string &value)
{
    if (datashareHelper_ == nullptr) {
        USB_HILOGE(MODULE_USB_SERVICE, "query error, datashareHelper_ is nullptr");
        return false;
    }
    USB_HILOGI(MODULE_USB_SERVICE, "start Update key = %{public}s", key.c_str());
    std::string queryValue = "";
    if (!Query(uri, key, queryValue)) {
        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s is cannot Query!", key.c_str());
        return Insert(uri, key, value);
    }
    DataShare::DataShareValuesBucket valuesBucket;
    DataShare::DataShareValueObject valueObj(value);
    valuesBucket.Put(SETTINGS_DATA_COLUMN_VALUE, valueObj);
    DataShare::DataSharePredicates predicates;
    predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
    int32_t result = datashareHelper_->Update(uri, predicates, valuesBucket);
    if (result == RDB_INVALID_VALUE) {
        USB_HILOGE(MODULE_USB_SERVICE, "fail to update %{public}s !", key.c_str());
        datashareHelper_->Release();
        return false;
    }
    USB_HILOGI(MODULE_USB_SERVICE, "UsbSettingDataShare: update success");
    datashareHelper_->NotifyChange(uri);
    datashareHelper_->Release();
    return true;
}
} // namespace USB
} // namespace OHOS