/*
 * Copyright (c) 2021-2024 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 "mission_data_storage.h"
#include <cstdio>
#include "directory_ex.h"
#include "file_ex.h"
#include "hilog_tag_wrapper.h"
#include "hitrace_meter.h"
#include "image_packer.h"
#include "image_source.h"
#include "media_errors.h"
#include "mission_info_mgr.h"
#ifdef SUPPORT_GRAPHICS
#include <cstdio>
#include "securec.h"
#endif

namespace OHOS {
namespace AAFwk {
namespace {
constexpr const char* IMAGE_FORMAT = "image/jpeg";
constexpr uint8_t IMAGE_QUALITY = 75;
}
#ifdef SUPPORT_GRAPHICS
constexpr int32_t RGB888_PIXEL_BYTES = 3;
const mode_t MODE = 0770;
#endif

MissionDataStorage::MissionDataStorage(int userId)
{
    userId_ = userId;
}

MissionDataStorage::~MissionDataStorage()
{}

bool MissionDataStorage::LoadAllMissionInfo(std::list<InnerMissionInfo> &missionInfoList)
{
    std::vector<std::string> fileNameVec;
    std::vector<int32_t> tempMissions;
    std::string dirPath = GetMissionDataDirPath();
    OHOS::GetDirFiles(dirPath, fileNameVec);

    for (auto fileName : fileNameVec) {
        if (!CheckFileNameValid(fileName)) {
            TAG_LOGE(AAFwkTag::ABILITYMGR, "load mission info: file name %{public}s invalid.", fileName.c_str());
            continue;
        }

        std::string content;
        bool loadFile = OHOS::LoadStringFromFile(fileName, content);
        if (!loadFile) {
            TAG_LOGE(AAFwkTag::ABILITYMGR, "load string from file %{public}s failed.", fileName.c_str());
            continue;
        }

        InnerMissionInfo misssionInfo;
        if (!misssionInfo.FromJsonStr(content)) {
            TAG_LOGE(AAFwkTag::ABILITYMGR, "parse mission info failed. file: %{public}s", fileName.c_str());
            continue;
        }
        if (misssionInfo.isTemporary) {
            tempMissions.push_back(misssionInfo.missionInfo.id);
            continue;
        }
        missionInfoList.push_back(misssionInfo);
    }

    for (auto missionId : tempMissions) {
        DeleteMissionInfo(missionId);
    }
    return true;
}

void MissionDataStorage::SaveMissionInfo(const InnerMissionInfo &missionInfo)
{
    std::string filePath = GetMissionDataFilePath(missionInfo.missionInfo.id);
    std::string dirPath = OHOS::ExtractFilePath(filePath);
    if (!OHOS::FileExists(dirPath)) {
        bool createDir = OHOS::ForceCreateDirectory(dirPath);
        if (!createDir) {
            TAG_LOGE(AAFwkTag::ABILITYMGR, "create dir %{public}s failed.", dirPath.c_str());
            return;
        }
        chmod(dirPath.c_str(), MODE);
    }

    std::string jsonStr = missionInfo.ToJsonStr();
    bool saveMissionFile = OHOS::SaveStringToFile(filePath, jsonStr, true);
    if (!saveMissionFile) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "save mission file %{public}s failed.", filePath.c_str());
    }
}

void MissionDataStorage::DeleteMissionInfo(int missionId)
{
    std::string filePath = GetMissionDataFilePath(missionId);
    bool removeMissionFile = OHOS::RemoveFile(filePath);
    if (!removeMissionFile) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "remove mission file %{public}s failed.", filePath.c_str());
        return;
    }
    DeleteMissionSnapshot(missionId);
}

void MissionDataStorage::SaveMissionSnapshot(int32_t missionId, const MissionSnapshot& missionSnapshot)
{
#ifdef SUPPORT_GRAPHICS
    TAG_LOGI(AAFwkTag::ABILITYMGR, "snapshot: save snapshot from cache, missionId = %{public}d", missionId);
    SaveCachedSnapshot(missionId, missionSnapshot);
    SaveSnapshotFile(missionId, missionSnapshot);
    TAG_LOGI(AAFwkTag::ABILITYMGR, "snapshot: delete snapshot from cache, missionId = %{public}d", missionId);
    DeleteCachedSnapshot(missionId);
#endif
}

void MissionDataStorage::DeleteMissionSnapshot(int32_t missionId)
{
#ifdef SUPPORT_GRAPHICS
    DeleteMissionSnapshot(missionId, false);
    DeleteMissionSnapshot(missionId, true);
#endif
}

bool MissionDataStorage::GetMissionSnapshot(int32_t missionId, MissionSnapshot& missionSnapshot, bool isLowResolution)
{
#ifdef SUPPORT_GRAPHICS
    HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
    if (GetCachedSnapshot(missionId, missionSnapshot)) {
        if (isLowResolution) {
            missionSnapshot.snapshot = GetReducedPixelMap(missionSnapshot.snapshot);
        }
        TAG_LOGI(AAFwkTag::ABILITYMGR, "snapshot: GetMissionSnapshot from cache, missionId = %{public}d", missionId);
        return true;
    }

    auto pixelMap = GetPixelMap(missionId, isLowResolution);
    if (!pixelMap) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "%{public}s: GetPixelMap failed.", __func__);
        return false;
    }
    missionSnapshot.snapshot = std::move(pixelMap);
#endif
    return true;
}

std::string MissionDataStorage::GetMissionDataDirPath() const
{
    return std::string(TASK_DATA_FILE_BASE_PATH) + "/" + std::to_string(userId_) + "/"
        + std::string(MISSION_DATA_FILE_PATH);
}

std::string MissionDataStorage::GetMissionDataFilePath(int missionId)
{
    return GetMissionDataDirPath() + "/"
        + MISSION_JSON_FILE_PREFIX + "_" + std::to_string(missionId) + JSON_FILE_SUFFIX;
}

std::string MissionDataStorage::GetMissionSnapshotPath(int32_t missionId, bool isLowResolution) const
{
    std::string filePath = GetMissionDataDirPath() + FILE_SEPARATOR + MISSION_JSON_FILE_PREFIX +
        UNDERLINE_SEPARATOR + std::to_string(missionId);
    if (isLowResolution) {
        filePath = filePath + UNDERLINE_SEPARATOR + LOW_RESOLUTION_FLAG;
    }
    filePath = filePath + JPEG_FILE_SUFFIX;
    return filePath;
}

bool MissionDataStorage::CheckFileNameValid(const std::string &fileName)
{
    std::string fileNameExcludePath = OHOS::ExtractFileName(fileName);
    if (fileNameExcludePath.find(MISSION_JSON_FILE_PREFIX) != 0) {
        return false;
    }

    if (fileNameExcludePath.find("_") != std::string(MISSION_JSON_FILE_PREFIX).length()) {
        return false;
    }

    if (fileNameExcludePath.find(JSON_FILE_SUFFIX) != fileNameExcludePath.length()
        - std::string(JSON_FILE_SUFFIX).length()) {
        return false;
    }

    size_t missionIdLength = fileNameExcludePath.find(JSON_FILE_SUFFIX) - fileNameExcludePath.find("_") - 1;
    std::string missionId = fileNameExcludePath.substr(fileNameExcludePath.find("_") + 1, missionIdLength);
    for (auto ch : missionId) {
        if (!isdigit(ch)) {
            return false;
        }
    }

    return true;
}

#ifdef SUPPORT_GRAPHICS
void MissionDataStorage::SaveSnapshotFile(int32_t missionId, const MissionSnapshot& missionSnapshot)
{
    SaveSnapshotFile(missionId, missionSnapshot.snapshot, missionSnapshot.isPrivate, false);
    SaveSnapshotFile(missionId, GetReducedPixelMap(missionSnapshot.snapshot), missionSnapshot.isPrivate, true);
    DelayedSingleton<MissionInfoMgr>::GetInstance()->CompleteSaveSnapshot(missionId);
}

void MissionDataStorage::SaveSnapshotFile(int32_t missionId, const std::shared_ptr<OHOS::Media::PixelMap>& snapshot,
    bool isPrivate, bool isLowResolution)
{
    if (!snapshot) {
        return;
    }

    std::string filePath = GetMissionSnapshotPath(missionId, isLowResolution);
    std::string dirPath = OHOS::ExtractFilePath(filePath);
    if (!OHOS::FileExists(dirPath)) {
        bool createDir = OHOS::ForceCreateDirectory(dirPath);
        if (!createDir) {
            TAG_LOGE(AAFwkTag::ABILITYMGR, "snapshot: create dir %{public}s failed.", dirPath.c_str());
            return;
        }
        chmod(dirPath.c_str(), MODE);
    }

    if (isPrivate) {
        TAG_LOGD(AAFwkTag::ABILITYMGR, "snapshot: the param isPrivate is true.");
        ssize_t dataLength = snapshot->GetWidth() * snapshot->GetHeight() * RGB888_PIXEL_BYTES;
        uint8_t* data = (uint8_t*) malloc(dataLength);
        if (data == nullptr) {
            TAG_LOGE(AAFwkTag::ABILITYMGR, "malloc failed.");
            return;
        }
        if (memset_s(data, dataLength, 0xff, dataLength) == EOK) {
            Media::SourceOptions sourceOptions;
            uint32_t errCode = 0;
            auto imageSource = Media::ImageSource::CreateImageSource(data, dataLength, sourceOptions, errCode);
            WriteToJpeg(filePath, *imageSource);
        }
        free(data);
    } else {
        WriteToJpeg(filePath, *snapshot);
    }
}

std::shared_ptr<OHOS::Media::PixelMap> MissionDataStorage::GetReducedPixelMap(
    const std::shared_ptr<OHOS::Media::PixelMap>& snapshot)
{
    if (!snapshot) {
        return nullptr;
    }

    OHOS::Media::InitializationOptions options;
    options.size.width = snapshot->GetWidth() / SCALE;
    options.size.height = snapshot->GetHeight() / SCALE;
    std::unique_ptr<OHOS::Media::PixelMap> reducedPixelMap = OHOS::Media::PixelMap::Create(*snapshot, options);
    return std::shared_ptr<OHOS::Media::PixelMap>(reducedPixelMap.release());
}

bool MissionDataStorage::GetCachedSnapshot(int32_t missionId, MissionSnapshot& missionSnapshot)
{
    std::lock_guard<ffrt::mutex> lock(cachedPixelMapMutex_);
    auto pixelMap = cachedPixelMap_.find(missionId);
    if (pixelMap != cachedPixelMap_.end()) {
        missionSnapshot.snapshot = pixelMap->second;
        return true;
    }
    return false;
}

bool MissionDataStorage::SaveCachedSnapshot(int32_t missionId, const MissionSnapshot& missionSnapshot)
{
    std::lock_guard<ffrt::mutex> lock(cachedPixelMapMutex_);
    auto result = cachedPixelMap_.insert_or_assign(missionId, missionSnapshot.snapshot);
    if (!result.second) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "snapshot: save snapshot cache failed, missionId = %{public}d", missionId);
        return false;
    }
    return true;
}

bool MissionDataStorage::DeleteCachedSnapshot(int32_t missionId)
{
    std::lock_guard<ffrt::mutex> lock(cachedPixelMapMutex_);
    auto result = cachedPixelMap_.erase(missionId);
    if (result != 1) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "snapshot: delete snapshot cache failed, missionId = %{public}d", missionId);
        return false;
    }
    return true;
}

void MissionDataStorage::DeleteMissionSnapshot(int32_t missionId, bool isLowResolution)
{
    std::string filePath = GetMissionSnapshotPath(missionId, isLowResolution);
    if (!OHOS::FileExists(filePath)) {
        TAG_LOGW(AAFwkTag::ABILITYMGR, "snapshot: remove snapshot file %{public}s failed, file not exists",
            filePath.c_str());
        return;
    }
    bool removeResult = OHOS::RemoveFile(filePath);
    if (!removeResult) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "snapshot: remove snapshot file %{public}s failed.", filePath.c_str());
    }
}

std::shared_ptr<Media::PixelMap> MissionDataStorage::GetSnapshot(int missionId, bool isLowResolution) const
{
    auto pixelMapPtr = GetPixelMap(missionId, isLowResolution);
    if (!pixelMapPtr) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "%{public}s: GetPixelMap failed.", __func__);
        return nullptr;
    }
    return std::shared_ptr<Media::PixelMap>(pixelMapPtr.release());
}

std::unique_ptr<uint8_t[]> MissionDataStorage::ReadFileToBuffer(const std::string &filePath, size_t &bufferSize) const
{
    struct stat statbuf;
    int ret = stat(filePath.c_str(), &statbuf);
    if (ret != 0) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "GetPixelMap: get the file size failed, ret:%{public}d.", ret);
        return nullptr;
    }
    bufferSize = static_cast<size_t>(statbuf.st_size);
    std::string realPath;
    if (!OHOS::PathToRealPath(filePath, realPath)) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "ReadFileToBuffer:file path to real path failed, file path=%{public}s.",
            filePath.c_str());
        return nullptr;
    }

    std::unique_ptr<uint8_t[]> buffer = std::make_unique<uint8_t[]>(bufferSize);
    if (buffer == nullptr) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "ReadFileToBuffer:buffer is nullptr");
        return nullptr;
    }

    FILE *fp = fopen(realPath.c_str(), "rb");
    if (fp == nullptr) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "ReadFileToBuffer:open file failed, real path=%{public}s.", realPath.c_str());
        return nullptr;
    }
    fseek(fp, 0, SEEK_END);
    size_t fileSize = static_cast<size_t>(ftell(fp));
    fseek(fp, 0, SEEK_SET);
    if (bufferSize < fileSize) {
        TAG_LOGE(AAFwkTag::ABILITYMGR,
            "ReadFileToBuffer:buffer size:(%{public}zu) is smaller than file size:(%{public}zu).", bufferSize,
            fileSize);
        fclose(fp);
        return nullptr;
    }
    size_t retSize = std::fread(buffer.get(), 1, fileSize, fp);
    if (retSize != fileSize) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "ReadFileToBuffer:read file result size = %{public}zu, size = %{public}zu.",
            retSize, fileSize);
        fclose(fp);
        return nullptr;
    }
    fclose(fp);
    return buffer;
}

std::unique_ptr<Media::PixelMap> MissionDataStorage::GetPixelMap(int missionId, bool isLowResolution) const
{
    std::string filePath = GetMissionSnapshotPath(missionId, isLowResolution);
    if (!OHOS::FileExists(filePath)) {
        TAG_LOGI(AAFwkTag::ABILITYMGR, "snapshot: storage snapshot not exists, missionId = %{public}d", missionId);
        return nullptr;
    }
    uint32_t errCode = 0;
    
    size_t bufferSize = 0;
    const std::string fileName = filePath;
    std::unique_ptr<uint8_t[]> buffer = MissionDataStorage::ReadFileToBuffer(fileName, bufferSize);
    if (buffer == nullptr) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "GetPixelMap: get buffer error buffer == nullptr");
        return nullptr;
    }
    Media::SourceOptions sourceOptions;
    auto imageSource = Media::ImageSource::CreateImageSource(buffer.get(), bufferSize, sourceOptions, errCode);
    if (errCode != OHOS::Media::SUCCESS || imageSource == nullptr) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "snapshot: CreateImageSource failed, nullptr or errCode = %{public}d", errCode);
        return nullptr;
    }
    Media::DecodeOptions decodeOptions;
    decodeOptions.allocatorType = Media::AllocatorType::SHARE_MEM_ALLOC;
    auto pixelMapPtr = imageSource->CreatePixelMap(decodeOptions, errCode);
    if (errCode != OHOS::Media::SUCCESS) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "snapshot: CreatePixelMap failed, errCode = %{public}d", errCode);
        return nullptr;
    }
    return pixelMapPtr;
}

template<typename T>
void MissionDataStorage::WriteToJpeg(const std::string &filePath, T &snapshot) const
{
    TAG_LOGI(AAFwkTag::ABILITYMGR, "file:%{public}s", filePath.c_str());
    OHOS::Media::PackOption option;
    option.format = IMAGE_FORMAT;
    option.quality = IMAGE_QUALITY;
    Media::ImagePacker imagePacker;
    uint32_t err = imagePacker.StartPacking(filePath, option);
    if (err != ERR_OK) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "Failed to StartPacking %{public}d.", err);
        return;
    }
    err = imagePacker.AddImage(snapshot);
    if (err != ERR_OK) {
        TAG_LOGE(AAFwkTag::ABILITYMGR, "Failed to AddImage %{public}d.", err);
        return;
    }
    int64_t packedSize = 0;
    imagePacker.FinalizePacking(packedSize);
}
#endif
}  // namespace AAFwk
}  // namespace OHOS