// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md

#include <purefs/fs/filesystem.hpp>
#include <purefs/fs/drivers/filesystem_vfat.hpp>
#include <purefs/fs/drivers/filesystem_littlefs.hpp>
#include <purefs/fs/drivers/filesystem_ext4.hpp>
#include <purefs/blkdev/disk_manager.hpp>
#include <purefs/vfs_subsystem.hpp>
#include <purefs/vfs_subsystem_internal.hpp>
#include <purefs/fs/thread_local_cwd.hpp>
#include <log/log.hpp>
#include <purefs/filesystem_paths.hpp>
#include <json11.hpp>
#include <sys/stat.h>
#include <fcntl.h>

namespace purefs::subsystem
{
    namespace
    {
        constexpr auto default_blkdev_name      = "emmc0";
        constexpr auto default_nvrom_name       = "nvrom0";
        constexpr auto fat_part_code            = 0x0B;
        constexpr auto lfs_part_code            = 0x9E;
        constexpr auto linux_part_code          = 0x83;
        constexpr auto layout_part_count        = 3;
        constexpr auto boot_part_index          = 0;
        constexpr auto user_part_index          = 2;
        constexpr auto boot_size_limit          = 16384L;
        constexpr auto block_size_max_shift     = 21;
        constexpr auto block_size_min_shift     = 8;
        constexpr uint32_t nvrom_lfs_block_size = 128U;
        namespace json
        {
            constexpr auto os_type = "ostype";
            constexpr auto main    = "main";
        } // namespace json
        std::weak_ptr<blkdev::disk_manager> g_disk_mgr;
        std::weak_ptr<fs::filesystem> g_fs_core;
    } // namespace

    namespace
    {
        int read_file_to_cpp_string(std::shared_ptr<fs::filesystem> vfs, std::string_view file, std::string &str)
        {
            int fd = vfs->open(file, O_RDONLY, 0664);
            if (fd < 0) {
                return fd;
            }
            size_t rd_pos  = 0;
            size_t to_read = str.size();
            do {
                int err = vfs->read(fd, &str[rd_pos], to_read);
                if (err < 0) {
                    vfs->close(fd);
                    return err;
                }
                else {
                    to_read -= err;
                    rd_pos += err;
                }
            } while (to_read > 0);
            return vfs->close(fd);
        }

        std::string parse_boot_json_directory(std::string_view file)
        {
            using namespace std::literals;
            auto vfsn = g_fs_core.lock();
            if (!vfsn) {
                LOG_ERROR("Unable to lock vfs. Fallback to current dir");
                return "current"s;
            }
            struct stat stbuf;
            int err = vfsn->stat(file, stbuf);
            if (err) {
                LOG_ERROR("Unable to lock vfs. Fallback to current dir");
                return "current"s;
            }
            if (stbuf.st_size > boot_size_limit) {
                LOG_ERROR("Boot file to long. Fallback to current dir");
                return "current"s;
            }
            std::string json_str(stbuf.st_size, ' ');
            std::string error;
            err = read_file_to_cpp_string(vfsn, file, json_str);
            if (err) {
                LOG_ERROR("Unable to read boot file (err: %i). Fallback to current dir", err);
                return "current"s;
            }
            auto json = json11::Json::parse(json_str, error);
            if (!error.empty()) {
                LOG_ERROR("Unable to parse json boot file (err: %s). Fallback to current dir", error.c_str());
                return "current"s;
            }
            return json[json::main][json::os_type].string_value();
        }

        int read_mbr_lfs_erase_size(std::shared_ptr<blkdev::disk_manager> disk_mngr,
                                    std::string_view dev_name,
                                    int part_no)
        {
            static constexpr auto MBR_ERASE_BLK_OFFSET = 0x00E0;
            if (part_no <= 0) {
                return -EINVAL;
            }
            const auto sect_size = disk_mngr->get_info(dev_name, blkdev::info_type::sector_size);
            if (sect_size <= MBR_ERASE_BLK_OFFSET + part_no) {
                return (sect_size > 0) ? (-ERANGE) : (sect_size);
            }
            auto mbr_buf = std::make_unique<char[]>(sect_size);
            int err      = disk_mngr->read(dev_name, mbr_buf.get(), 0, 1);
            if (err < 0) {
                return err;
            }
            return mbr_buf[MBR_ERASE_BLK_OFFSET + part_no];
        }

    } // namespace

    auto initialize(std::unique_ptr<DeviceFactory> deviceFactory)
        -> std::tuple<std::shared_ptr<blkdev::disk_manager>, std::shared_ptr<fs::filesystem>>
    {
        auto disk_mgr                            = std::make_shared<blkdev::disk_manager>();
        const std::shared_ptr<blkdev::disk> bdev = deviceFactory->makeDefaultBlockDevice();
        auto err                                 = disk_mgr->register_device(bdev, default_blkdev_name);
        if (err) {
            LOG_FATAL("Unable to register block device with error %i", err);
            return {};
        }
        const std::shared_ptr<blkdev::disk> nvrom_bdev = deviceFactory->makeDefaultNvmDevice();
        if (nvrom_bdev) {
            err = disk_mgr->register_device(nvrom_bdev, default_nvrom_name, blkdev::flags::no_parts_scan);
            if (err) {
                LOG_WARN("Unable to register NVROM device err %i. Possible: NVROM unavailable", err);
            }
        }
        else {
            LOG_WARN("No NVROM driver available for this platform");
        }
        auto fs_core = std::make_shared<fs::filesystem>(disk_mgr);
        err          = fs_core->register_filesystem("vfat", std::make_shared<fs::drivers::filesystem_vfat>());
        if (err) {
            LOG_FATAL("Unable to register vfat filesystem with error %i", err);
            return {};
        }
        err = fs_core->register_filesystem("littlefs", std::make_shared<fs::drivers::filesystem_littlefs>());
        if (err) {
            LOG_FATAL("Unable to register lfs filesystem with error %i", err);
            return {};
        }
        err = fs_core->register_filesystem("ext4", std::make_shared<fs::drivers::filesystem_ext4>());
        if (err) {
            LOG_FATAL("Unable to register ext4 filesystem with error %i", err);
            return {};
        }

        g_disk_mgr = disk_mgr;
        g_fs_core  = fs_core;
        return {disk_mgr, fs_core};
    }

    auto disk_mgr() -> std::shared_ptr<blkdev::disk_manager>
    {
        return g_disk_mgr.lock();
    }

    auto vfs_core() -> std::shared_ptr<fs::filesystem>
    {
        return g_fs_core.lock();
    }

    auto mount_defaults() -> int
    {
        auto disk = g_disk_mgr.lock();
        if (!disk) {
            LOG_FATAL("Unable to lock disk");
            return -EIO;
        }
        const auto parts = disk->partitions(default_blkdev_name);
        if (parts.size() != layout_part_count) {
            LOG_FATAL("Unknown partitions layout part size is %u", (unsigned)(parts.size()));
            return -EIO;
        }
        const auto &boot_part = parts[boot_part_index];
        const auto &user_part = parts[user_part_index];
        if (!boot_part.bootable) {
            LOG_FATAL("First partition is not bootable");
            return -EIO;
        }
        if ((boot_part.type != fat_part_code) && (boot_part.type != linux_part_code)) {
            LOG_FATAL("Invalid boot partition type expected code: %02X or %02X current code: %02X",
                      fat_part_code,
                      linux_part_code,
                      boot_part.type);
            return -EIO;
        }
        if (user_part.type != linux_part_code) {
            LOG_FATAL(
                "Invalid user partition type expected code: %02X current code: %02X", linux_part_code, user_part.type);
            return -EIO;
        }
        auto vfs = g_fs_core.lock();
        if (!vfs) {
            LOG_FATAL("Unable to lock vfs core");
            return -EIO;
        }
        auto err =
            vfs->mount(boot_part.name, purefs::dir::getRootDiskPath().string(), "auto", fs::mount_flags::read_only);
        if (err) {
            return err;
        }
        if (user_part.type == lfs_part_code) {
            const int lfs_block_log2 = read_mbr_lfs_erase_size(disk, default_blkdev_name, user_part.physical_number);
            uint32_t lfs_block_size  = 0;
            uint32_t *lfs_block_size_ptr = nullptr;
            if (lfs_block_log2 >= block_size_min_shift && lfs_block_log2 <= block_size_max_shift) {
                lfs_block_size     = 1U << lfs_block_log2;
                lfs_block_size_ptr = &lfs_block_size;
            }
            err =
                vfs->mount(user_part.name, purefs::dir::getUserDiskPath().string(), "littlefs", 0, lfs_block_size_ptr);
        }
        else {
            err = vfs->mount(user_part.name, purefs::dir::getUserDiskPath().string(), "ext4");
        }
        const std::string json_file = (dir::getRootDiskPath() / file::boot_json).string();
        const auto boot_dir_name    = parse_boot_json_directory(json_file);
        const auto user_dir         = (dir::getRootDiskPath() / boot_dir_name).string();
        fs::internal::set_default_thread_cwd(user_dir);

        // Mount NVRAM memory
        err = vfs->mount(default_nvrom_name,
                         purefs::dir::getMfgConfPath().c_str(),
                         "littlefs",
                         fs::mount_flags::read_only,
                         &nvrom_lfs_block_size);
        if (err) {
            LOG_WARN("Unable to mount NVROM partition err %i. Possible: NVROM unavailable", err);
            err = 0;
        }
        return err;
    }

    auto unmount_all() -> int
    {
        auto vfs = g_fs_core.lock();
        if (!vfs) {
            LOG_ERROR("Unable to lock vfs");
            return -EIO;
        }
        std::list<std::string> mount_points;
        int err = vfs->read_mountpoints(mount_points);
        if (err) {
            return err;
        }
        for (const auto &mpoint : mount_points) {
            err = vfs->umount(mpoint);
            if (err)
                break;
        }
        return err;
    }

} // namespace purefs::subsystem