// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.


#include <minfs/inspector.h>

#include <sys/stat.h>

#include <fbl/unique_fd.h>
#include <lib/disk-inspector/common-types.h>
#include <minfs/bcache.h>

#include "inspector-private.h"

namespace minfs {

namespace {
std::unique_ptr<disk_inspector::DiskObjectUint64> CreateUint64DiskObj(fbl::String fieldName,
                                                                      const uint64_t* value) {
    return std::make_unique<disk_inspector::DiskObjectUint64>(fieldName, value);
}

std::unique_ptr<disk_inspector::DiskObjectUint32> CreateUint32DiskObj(fbl::String fieldName,
                                                                      const uint32_t* value) {
    return std::make_unique<disk_inspector::DiskObjectUint32>(fieldName, value);
}

std::unique_ptr<disk_inspector::DiskObjectUint64Array> CreateUint64ArrayDiskObj(
                                                                     fbl::String fieldName,
                                                                     const uint64_t* value,
                                                                     size_t size) {
    return std::make_unique<disk_inspector::DiskObjectUint64Array>(fieldName, value, size);
}

std::unique_ptr<disk_inspector::DiskObjectUint32Array> CreateUint32ArrayDiskObj(
                                                                    fbl::String fieldName,
                                                                    const uint32_t* value,
                                                                    size_t size) {
    return std::make_unique<disk_inspector::DiskObjectUint32Array>(fieldName, value, size);
}

} // namespace

void InodeObject::GetValue(const void** out_buffer, size_t* out_buffer_size) const {
    ZX_DEBUG_ASSERT_MSG(false, "Invalid GetValue call for non primitive data type.");
}

std::unique_ptr<disk_inspector::DiskObject> InodeObject::GetElementAt(uint32_t index) const {
    switch (index) {
        case 0: {
            // uint32_t magic
            return CreateUint32DiskObj("magic", &(inode_.magic));
        }
        case 1: {
            // uint32_t size
            return CreateUint32DiskObj("size", &(inode_.size));
        }
        case 2: {
            // uint32_t block_count
            return CreateUint32DiskObj("block_count", &(inode_.block_count));
        }
        case 3: {
            // uint32_t link_count
            return CreateUint32DiskObj("link_count", &(inode_.link_count));
        }
        case 4: {
            // uint64_t create_time
            return CreateUint64DiskObj("create_time", &(inode_.create_time));
        }
        case 5: {
            // uint64_t modify_time
            return CreateUint64DiskObj("modify_time", &(inode_.modify_time));
        }
        case 6: {
            // uint32_t seq_num
            return CreateUint32DiskObj("seq_num", &(inode_.seq_num));
        }
        case 7: {
            // uint32_t gen_num
            return CreateUint32DiskObj("gen_num", &(inode_.gen_num));
        }
        case 8: {
            // uint32_t dirent_count
            return CreateUint32DiskObj("dirent_count", &(inode_.dirent_count));
        }
        case 9: {
            // ino_t/uint32_t last_inode
            return CreateUint32DiskObj("last_inode", &(inode_.last_inode));
        }
        case 10: {
            // ino_t/uint32_t next_inode
            return CreateUint32DiskObj("next_inode", &(inode_.next_inode));
        }
        case 11: {
            //uint32_t Array rsvd
            return CreateUint32ArrayDiskObj("reserved", inode_.rsvd, 3);
        }
        case 12: {
            // blk_t/uint32_t Array dnum
            return CreateUint32ArrayDiskObj("direct blocks", inode_.dnum, kMinfsDirect);
        }
        case 13: {
            // blk_t/uint32_t Array inum
            return CreateUint32ArrayDiskObj("indirect blocks", inode_.inum, kMinfsIndirect);
        }
        case 14: {
            // blk_t/uint32_t Array dinum
            return CreateUint32ArrayDiskObj("double indirect blocks", inode_.dinum,
                                            kMinfsDoublyIndirect);
        }
    }
    return nullptr;
}

void InodeTableObject::GetValue(const void** out_buffer, size_t* out_buffer_size) const {
    ZX_DEBUG_ASSERT_MSG(false, "Invalid GetValue call for non primitive data type.");
}

std::unique_ptr<disk_inspector::DiskObject> InodeTableObject::GetElementAt(uint32_t index) const {
    if (index >= inode_count_) {
        return nullptr;
    }
    return GetInode(static_cast<ino_t>(index));
}

std::unique_ptr<disk_inspector::DiskObject> InodeTableObject::GetInode(ino_t inode) const {
    Inode inode_obj;
    inode_table_->Load(inode, &inode_obj);
    return std::unique_ptr<disk_inspector::DiskObject>(new InodeObject(inode_obj));
}

void SuperBlockObject::GetValue(const void** out_buffer, size_t* out_buffer_size) const {
    ZX_DEBUG_ASSERT_MSG(false, "Invalid GetValue call for non primitive data type.");
}

std::unique_ptr<disk_inspector::DiskObject> SuperBlockObject::GetElementAt(uint32_t index) const {
    switch (index) {
        case 0: {
            // uint64_t magic0
            return CreateUint64DiskObj("magic0", &(sb_.magic0));
        }
        case 1: {
            // uint64_t magic1
            return CreateUint64DiskObj("magic1", &(sb_.magic1));
        }
        case 2: {
            // uint32_t version
            return CreateUint32DiskObj("version", &(sb_.version));
        }
        case 3: {
            // uint32_t flags
            return CreateUint32DiskObj("flags", &(sb_.flags));
        }
        case 4: {
            // uint32_t block_size
            return CreateUint32DiskObj("block_size", &(sb_.block_size));
        }
        case 5: {
            // uint32_t inode_size
            return CreateUint32DiskObj("inode_size", &(sb_.inode_size));
        }
        case 6: {
            // uint32_t block_count
            return CreateUint32DiskObj("block_count", &(sb_.block_count));
        }
        case 7: {
            // uint32_t inode_count
            return CreateUint32DiskObj("inode_count", &(sb_.inode_count));
        }
        case 8: {
            // uint32_t alloc_block_count
            return CreateUint32DiskObj("alloc_block_count",
                        &(sb_.alloc_block_count));
        }
        case 9: {
            // uint32_t alloc_inode_count
            return CreateUint32DiskObj("alloc_inode_count", &(sb_.alloc_inode_count));
        }
        case 10: {
            // uint32_t/blk_t ibm_block
            return CreateUint32DiskObj("ibm_block", &(sb_.ibm_block));
        }
        case 11: {
            // uint32_t/blk_t abm_block
            return CreateUint32DiskObj("abm_block", &(sb_.abm_block));
        }
        case 12: {
            // uint32_t/blk_t ino_block
            return CreateUint32DiskObj("ino_block", &(sb_.ino_block));
        }
        case 13: {
            // uint32_t/blk_t journal_start_block
            return CreateUint32DiskObj("journal_start_block", &(sb_.journal_start_block));
        }
        case 14: {
            // uint32_t/blk_t dat_block
            return CreateUint32DiskObj("dat_block", &(sb_.dat_block));
        }
        case 15: {
            // uint64_t slice_size
            return CreateUint64DiskObj("slice_size", &(sb_.slice_size));
        }
        case 16: {
            // uint64_t vslice_count
            return CreateUint64DiskObj("vslice_count", &(sb_.vslice_count));
        }
        case 17: {
            // uint32_t ibm_slices
            return CreateUint32DiskObj("ibm_slices", &(sb_.ibm_slices));
        }
        case 18: {
            // uint32_t abm_slices
            return CreateUint32DiskObj("abm_slices", &(sb_.abm_slices));
        }
        case 19: {
            // uint32_t ino_slices
            return CreateUint32DiskObj("ino_slices", &(sb_.ino_slices));
        }
        case 20: {
            // uint32_t journal_slices
            return CreateUint32DiskObj("journal_slices", &(sb_.journal_slices));
        }
        case 21: {
            // uint32_t dat_slices
            return CreateUint32DiskObj("dat_slices", &(sb_.dat_slices));
        }
        case 22: {
            // uint32_t/ino_t unlinked_head
            return CreateUint32DiskObj("unlinked_head", &(sb_.unlinked_head));
        }
        case 23: {
            // uint32_t/ino_t unlinked_tail
            return CreateUint32DiskObj("unlinked_tail", &(sb_.unlinked_tail));
        }
    }
    return nullptr;
}

void JournalObject::GetValue(const void** out_buffer, size_t* out_buffer_size) const  {
    ZX_DEBUG_ASSERT_MSG(false, "Invalid GetValue call for non primitive data type.");
}

std::unique_ptr<disk_inspector::DiskObject> JournalObject::GetElementAt(uint32_t index) const {
    switch (index) {
        case 0: {
            // uint64_t magic
            return CreateUint64DiskObj("magic", &(journal_info_->magic));
        }
        case 1: {
            // uint64_t reserved0
            return CreateUint64DiskObj("reserved0", &(journal_info_->reserved0));
        }
        case 2: {
            // uint64_t reserved1
            return CreateUint64DiskObj("reserved1", &(journal_info_->reserved1));
        }
        case 3: {
            // uint64_t reserved2
            return CreateUint64DiskObj("reserved2", &(journal_info_->reserved2));
        }
        case 4: {
            // uint64_t reserved3
            return CreateUint64DiskObj("reserved3", &(journal_info_->reserved3));
        }
    }
    return nullptr;
}

zx_status_t Inspector::GetRoot(std::unique_ptr<disk_inspector::DiskObject> *out) {
    std::unique_ptr<minfs::Bcache> bc;
    struct stat stats;
    if (fstat(fd_.get(), &stats) < 0) {
        fprintf(stderr, "minfsInspector: could not find end of file/device\n");
        return ZX_ERR_IO;
    }

    if (stats.st_size == 0) {
        fprintf(stderr, "minfsInspector: invalid disk size\n");
        return ZX_ERR_IO;
    }

    size_t size = stats.st_size / minfs::kMinfsBlockSize;

    if (minfs::Bcache::Create(&bc, std::move(fd_), static_cast<uint32_t>(size)) < 0) {
        fprintf(stderr, "minfsInspector: cannot create block cache\n");
        return ZX_ERR_IO;
    }

    zx_status_t status = CreateRoot(std::move(bc), out);
    if (status != ZX_OK) {
        fprintf(stderr, "minfsInspector: cannot create root object\n");
        return status;
    }
    return ZX_OK;
}

zx_status_t Inspector::CreateRoot(std::unique_ptr<Bcache> bc,
                                  std::unique_ptr<disk_inspector::DiskObject>* out) {
    zx_status_t status = ZX_OK;
    char data[kMinfsBlockSize];
    if (bc->Readblk(0, data) < 0) {
        FS_TRACE_ERROR("minfsInspector: could not read superblock\n");
        return ZX_ERR_IO;
    }
    const Superblock* info = reinterpret_cast<const Superblock*>(data);
    std::unique_ptr<Minfs> fs;
    if ((status = Minfs::Create(std::move(bc), info, &fs, IntegrityCheck::kNone)) != ZX_OK) {
        FS_TRACE_ERROR("minfsInspector: Create Failed to Create Minfs: %d\n", status);
        return status;
    }
    *out = std::unique_ptr<disk_inspector::DiskObject>(new RootObject(std::move(fs)));
    return ZX_OK;
}

std::unique_ptr<disk_inspector::DiskObject> RootObject::GetSuperBlock() const {
    return std::unique_ptr<disk_inspector::DiskObject>(new SuperBlockObject(fs_->Info()));
}

std::unique_ptr<disk_inspector::DiskObject> RootObject::GetInodeTable() const {
    return std::unique_ptr<disk_inspector::DiskObject>(new InodeTableObject(fs_->GetInodeManager(),
                                                       fs_->Info().alloc_inode_count));
}

std::unique_ptr<disk_inspector::DiskObject> RootObject::GetJournalInfo() const {
    char data[kMinfsBlockSize];

    if (fs_->ReadBlock(fs_->Info().journal_start_block, data) < 0) {
        FS_TRACE_ERROR("minfsInspector: could not read journal block\n");
        return nullptr;
    }

    JournalInfo* info = reinterpret_cast<JournalInfo*>(data);
    std::unique_ptr<JournalInfo> journal_info(new JournalInfo);
    memcpy(journal_info.get(), info, sizeof(*info));
    return std::unique_ptr<disk_inspector::DiskObject>(new JournalObject(std::move(journal_info)));
}

void RootObject::GetValue(const void** out_buffer, size_t* out_buffer_size) const {
    ZX_DEBUG_ASSERT_MSG(false, "Invalid GetValue call for non primitive data type.");
}

std::unique_ptr<disk_inspector::DiskObject> RootObject::GetElementAt(uint32_t index) const {
    switch (index) {
        case 0: {
            // Super Block
            return GetSuperBlock();
        }
        case 1: {
            // Inode Table
            return GetInodeTable();
        }
        case 2: {
            // Journal
            return GetJournalInfo();
        }
    };
    return nullptr;
}

} // namespace minfs