/*
 * 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 <libfiemap/split_fiemap_writer.h>

#include <fcntl.h>
#include <stdint.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include <memory>
#include <string>
#include <vector>

#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/scopeguard.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <android-base/unique_fd.h>

#include "utility.h"

namespace android {
namespace fiemap {

using android::base::unique_fd;

// We use a four-digit suffix at the end of filenames.
static const size_t kMaxFilePieces = 500;

// Helper to write a list of filenames for split file list.
static FiemapStatus WriteSplitFileList(const std::string& out_file,
                                       const std::vector<std::string>& files) {
    unique_fd fd(open(out_file.c_str(), O_CREAT | O_TRUNC | O_WRONLY | O_CLOEXEC, 0660));
    if (fd < 0) {
        PLOG(ERROR) << "Failed to open " << out_file;
        return FiemapStatus::FromErrno(errno);
    }

    for (const auto& file_path : files) {
        std::string line = android::base::Basename(file_path) + "\n";
        if (!android::base::WriteStringToFd(line, fd)) {
            PLOG(ERROR) << "Write failed " << out_file;
            return FiemapStatus::FromErrno(errno);
        }
    }
    fsync(fd.get());
    return FiemapStatus::Ok();
}

std::unique_ptr<SplitFiemap> SplitFiemap::Create(const std::string& file_path, uint64_t file_size,
                                                 uint64_t max_piece_size,
                                                 ProgressCallback progress) {
    std::unique_ptr<SplitFiemap> ret;
    if (!Create(file_path, file_size, max_piece_size, &ret, progress).is_ok()) {
        return nullptr;
    }
    return ret;
}

FiemapStatus SplitFiemap::Create(const std::string& file_path, uint64_t file_size,
                                 uint64_t max_piece_size, std::unique_ptr<SplitFiemap>* out_val,
                                 ProgressCallback progress) {
    out_val->reset();

    if (!file_size) {
        LOG(ERROR) << "Cannot create a fiemap for a 0-length file: " << file_path;
        return FiemapStatus::Error();
    }

    if (!max_piece_size) {
        auto status = DetermineMaximumFileSize(file_path, &max_piece_size);
        if (!status.is_ok()) {
            LOG(ERROR) << "Could not determine maximum file size for " << file_path;
            return status;
        }
    }

    // Remove any existing file.
    RemoveSplitFiles(file_path);

    // Call |progress| only when the total percentage would significantly change.
    int permille = -1;
    uint64_t total_bytes_written = 0;
    auto on_progress = [&](uint64_t written, uint64_t) -> bool {
        uint64_t actual_written = total_bytes_written + written;
        int new_permille = (actual_written * 1000) / file_size;
        if (new_permille != permille && actual_written < file_size) {
            if (progress && !progress(actual_written, file_size)) {
                return false;
            }
            permille = new_permille;
        }
        return true;
    };
    std::unique_ptr<SplitFiemap> out(new SplitFiemap());
    out->creating_ = true;
    out->list_file_ = file_path;

    // Create the split files.
    uint64_t remaining_bytes = file_size;
    while (remaining_bytes) {
        if (out->files_.size() >= kMaxFilePieces) {
            LOG(ERROR) << "Requested size " << file_size << " created too many split files";
            out.reset();
            return FiemapStatus::Error();
        }
        std::string chunk_path =
                android::base::StringPrintf("%s.%04d", file_path.c_str(), (int)out->files_.size());
        uint64_t chunk_size = std::min(max_piece_size, remaining_bytes);
        FiemapUniquePtr writer;
        auto status = FiemapWriter::Open(chunk_path, chunk_size, &writer, true, on_progress);
        if (!status.is_ok()) {
            out.reset();
            return status;
        }

        // To make sure the alignment doesn't create too much inconsistency, we
        // account the *actual* size, not the requested size.
        total_bytes_written += writer->size();

        // writer->size() is block size aligned and could be bigger than remaining_bytes
        // If remaining_bytes is bigger, set remaining_bytes to 0 to avoid underflow error.
        remaining_bytes = remaining_bytes > writer->size() ? (remaining_bytes - writer->size()) : 0;

        out->AddFile(std::move(writer));
    }

    // Create the split file list.
    std::vector<std::string> split_file_paths;
    split_file_paths.reserve(out->files_.size());
    for (const auto& file : out->files_) {
        split_file_paths.emplace_back(file->file_path());
    }
    if (auto status = WriteSplitFileList(file_path, split_file_paths); !status.is_ok()) {
        out.reset();
        return status;
    }

    // Unset this bit, so we don't unlink on destruction.
    out->creating_ = false;
    *out_val = std::move(out);
    return FiemapStatus::Ok();
}

std::unique_ptr<SplitFiemap> SplitFiemap::Open(const std::string& file_path) {
    std::vector<std::string> files;
    if (!GetSplitFileList(file_path, &files)) {
        return nullptr;
    }

    std::unique_ptr<SplitFiemap> out(new SplitFiemap());
    out->list_file_ = file_path;

    for (const auto& file : files) {
        auto writer = FiemapWriter::Open(file, 0, false);
        if (!writer) {
            // Error was logged in Open().
            return nullptr;
        }
        out->AddFile(std::move(writer));
    }
    return out;
}

bool SplitFiemap::GetSplitFileList(const std::string& file_path, std::vector<std::string>* list) {
    // This is not the most efficient thing, but it is simple and recovering
    // the fiemap/fibmap is much more expensive.
    std::string contents;
    if (!android::base::ReadFileToString(file_path, &contents, true)) {
        PLOG(ERROR) << "Error reading file: " << file_path;
        return false;
    }

    std::vector<std::string> names = android::base::Split(contents, "\n");
    std::string dir = android::base::Dirname(file_path);
    for (const auto& name : names) {
        if (!name.empty()) {
            list->emplace_back(dir + "/" + name);
        }
    }
    return true;
}

bool SplitFiemap::RemoveSplitFiles(const std::string& file_path, std::string* message) {
    // Early exit if this does not exist, and do not report an error.
    if (access(file_path.c_str(), F_OK) && errno == ENOENT) {
        return true;
    }

    bool ok = true;
    std::vector<std::string> files;
    if (GetSplitFileList(file_path, &files)) {
        for (const auto& file : files) {
            if (access(file.c_str(), F_OK) != 0 && (errno == ENOENT || errno == ENAMETOOLONG)) {
                continue;
            }
            truncate(file.c_str(), 0);
            ok &= android::base::RemoveFileIfExists(file, message);
        }
    }
    truncate(file_path.c_str(), 0);
    ok &= android::base::RemoveFileIfExists(file_path, message);
    sync();
    return ok;
}

bool SplitFiemap::HasPinnedExtents() const {
    for (const auto& file : files_) {
        if (!FiemapWriter::HasPinnedExtents(file->file_path())) {
            return false;
        }
    }
    return true;
}

const std::vector<struct fiemap_extent>& SplitFiemap::extents() {
    if (extents_.empty()) {
        for (const auto& file : files_) {
            const auto& extents = file->extents();
            extents_.insert(extents_.end(), extents.begin(), extents.end());
        }
    }
    return extents_;
}

bool SplitFiemap::Write(const void* data, uint64_t bytes) {
    // Open the current file.
    FiemapWriter* file = files_[cursor_index_].get();

    const uint8_t* data_ptr = reinterpret_cast<const uint8_t*>(data);
    uint64_t bytes_remaining = bytes;
    while (bytes_remaining) {
        // How many bytes can we write into the current file?
        uint64_t file_bytes_left = file->size() - cursor_file_pos_;
        if (!file_bytes_left) {
            if (cursor_index_ == files_.size() - 1) {
                LOG(ERROR) << "write past end of file requested";
                return false;
            }

            // No space left in the current file, but we have more files to
            // use, so prep the next one.
            cursor_fd_ = {};
            cursor_file_pos_ = 0;
            file = files_[++cursor_index_].get();
            file_bytes_left = file->size();
        }

        // Open the current file if it's not open.
        if (cursor_fd_ < 0) {
            cursor_fd_.reset(open(file->file_path().c_str(), O_CLOEXEC | O_WRONLY));
            if (cursor_fd_ < 0) {
                PLOG(ERROR) << "open failed: " << file->file_path();
                return false;
            }
            CHECK(cursor_file_pos_ == 0);
        }

        if (!FiemapWriter::HasPinnedExtents(file->file_path())) {
            LOG(ERROR) << "file is no longer pinned: " << file->file_path();
            return false;
        }

        uint64_t bytes_to_write = std::min(file_bytes_left, bytes_remaining);
        if (!android::base::WriteFully(cursor_fd_, data_ptr, bytes_to_write)) {
            PLOG(ERROR) << "write failed: " << file->file_path();
            return false;
        }
        data_ptr += bytes_to_write;
        bytes_remaining -= bytes_to_write;
        cursor_file_pos_ += bytes_to_write;
    }

    // If we've reached the end of the current file, close it.
    if (cursor_file_pos_ == file->size()) {
        cursor_fd_ = {};
    }
    return true;
}

bool SplitFiemap::Flush() {
    for (const auto& file : files_) {
        unique_fd fd(open(file->file_path().c_str(), O_RDONLY | O_CLOEXEC));
        if (fd < 0) {
            PLOG(ERROR) << "open failed: " << file->file_path();
            return false;
        }
        if (fsync(fd)) {
            PLOG(ERROR) << "fsync failed: " << file->file_path();
            return false;
        }
    }
    return true;
}

bool SplitFiemap::Grow(uint64_t bytes, uint64_t max_piece_size) {
    std::string temp_list_file = list_file_ + ".tmp";

    if (!max_piece_size) {
        // use temp file to determine the maximum file size because DetermineMaximumFileSize()
        // truncates the file if it already exists.
        auto status = DetermineMaximumFileSize(temp_list_file, &max_piece_size);
        if (!status.is_ok()) {
            LOG(ERROR) << "Could not determine maximum file size for " << temp_list_file;
            return false;
        }
    }

    // Create the split files. New files won't be added to the SplitFiemap instance until all files
    // are created and the split file list is updated.
    std::vector<FiemapUniquePtr> new_files;
    // On error, unlink new files
    auto guard = base::make_scope_guard([&]() {
        for (const auto& file : new_files) {
            unlink(file->file_path().c_str());
        }
    });

    uint64_t remaining_bytes = bytes;
    while (remaining_bytes) {
        auto files_size = files_.size() + new_files.size();
        if (files_size >= kMaxFilePieces) {
            LOG(ERROR) << "Requested size " << (total_size_ + bytes)
                       << " created too many split files";
            return false;
        }
        std::string chunk_path =
                android::base::StringPrintf("%s.%04d", list_file_.c_str(), (int)files_size);
        uint64_t chunk_size = std::min(max_piece_size, remaining_bytes);
        FiemapUniquePtr writer;
        auto status = FiemapWriter::Open(chunk_path, chunk_size, &writer, true);
        if (!status.is_ok()) {
            return false;
        }

        // writer->size() is block size aligned and could be bigger than remaining_bytes
        // If remaining_bytes is bigger, set remaining_bytes to 0 to avoid underflow error.
        remaining_bytes = remaining_bytes > writer->size() ? (remaining_bytes - writer->size()) : 0;
        new_files.push_back(std::move(writer));
    }

    // Update list file by appending new files at the end
    std::vector<std::string> split_file_paths;
    for (const auto& file : files_) {
        split_file_paths.emplace_back(file->file_path());
    }
    for (const auto& file : new_files) {
        split_file_paths.emplace_back(file->file_path());
    }
    // Write the list file to a temp first and then rename it for safer/atomic write.
    if (auto status = WriteSplitFileList(temp_list_file, split_file_paths); !status.is_ok()) {
        return false;
    }
    if (rename(temp_list_file.c_str(), list_file_.c_str())) {
        PLOG(ERROR) << "Failed to rename " << temp_list_file << " to " << list_file_;
        return false;
    }

    // Commit the changes to the SplitFiemap instance
    guard.Disable();
    for (auto&& file : new_files) {
        AddFile(std::move(file));
    }
    extents_.clear();  // will be populated later on demand in extents()
    return true;
}

SplitFiemap::~SplitFiemap() {
    if (!creating_) {
        return;
    }

    // We failed to finish creating, so unlink everything.
    unlink(list_file_.c_str());
    for (auto&& file : files_) {
        std::string path = file->file_path();
        file = nullptr;

        unlink(path.c_str());
    }
}

void SplitFiemap::AddFile(FiemapUniquePtr&& file) {
    total_size_ += file->size();
    files_.emplace_back(std::move(file));
}

uint32_t SplitFiemap::block_size() const {
    return files_[0]->block_size();
}

const std::string& SplitFiemap::bdev_path() const {
    return files_[0]->bdev_path();
}

}  // namespace fiemap
}  // namespace android
