// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you 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.

//

// This file is copied from

// https://github.com/apache/impala/blob/master/be/src/runtime/io/handle-cache.inline.h

// and modified by Doris

#include "io/fs/file_handle_cache.h"

#include <cstdint>

#include <thread>

#include <tuple>

#include "common/cast_set.h"

#include "io/fs/err_utils.h"

#include "util/hash_util.hpp"

#include "util/time.h"

namespace doris::io {

HdfsFileHandle::~HdfsFileHandle() {

    if (_hdfs_file != nullptr && _fs != nullptr) {

        VLOG_FILE << "hdfsCloseFile() fid=" << _hdfs_file;

        hdfsCloseFile(_fs, _hdfs_file); // TODO: check return code

    }

    _fs = nullptr;

    _hdfs_file = nullptr;

}

Status HdfsFileHandle::init(int64_t file_size) {

    _hdfs_file = hdfsOpenFile(_fs, _fname.c_str(), O_RDONLY, 0, 0, 0);

    if (_hdfs_file == nullptr) {

        std::string _err_msg = hdfs_error();

        // invoker maybe just skip Status.NotFound and continue

        // so we need distinguish between it and other kinds of errors

        if (_err_msg.find("No such file or directory") != std::string::npos) {

            return Status::NotFound(_err_msg);

        }

        return Status::InternalError("failed to open {}: {}", _fname, _err_msg);

    }

    _file_size = file_size;

    if (_file_size <= 0) {

        hdfsFileInfo* file_info = hdfsGetPathInfo(_fs, _fname.c_str());

        if (file_info == nullptr) {

            return Status::InternalError("failed to get file size of {}: {}", _fname, hdfs_error());

        }

        _file_size = file_info->mSize;

        hdfsFreeFileInfo(file_info, 1);

    }

    return Status::OK();

}

CachedHdfsFileHandle::CachedHdfsFileHandle(const hdfsFS& fs, const std::string& fname,

                                           int64_t mtime)

        : HdfsFileHandle(fs, fname, mtime) {}

CachedHdfsFileHandle::~CachedHdfsFileHandle() {}

FileHandleCache::Accessor::Accessor() : _cache_accessor() {}

FileHandleCache::Accessor::Accessor(FileHandleCachePartition::CacheType::Accessor&& cache_accessor)

        : _cache_accessor(std::move(cache_accessor)) {}

void FileHandleCache::Accessor::set(

        FileHandleCachePartition::CacheType::Accessor&& cache_accessor) {

    _cache_accessor = std::move(cache_accessor);

}

CachedHdfsFileHandle* FileHandleCache::Accessor::get() {

    return _cache_accessor.get();

}

void FileHandleCache::Accessor::release() {

    if (_cache_accessor.get()) {

        _cache_accessor.release();

    }

}

void FileHandleCache::Accessor::destroy() {

    if (_cache_accessor.get()) {

        _cache_accessor.destroy();

    }

}

FileHandleCache::Accessor::~Accessor() {

    if (_cache_accessor.get()) {

#ifdef USE_HADOOP_HDFS

        if (hdfsUnbufferFile(get()->file()) != 0) {

            VLOG_FILE << "FS does not support file handle unbuffering, closing file="

                      << _cache_accessor.get_key()->second.first;

            destroy();

        } else {

            // Calling explicit release to handle metrics

            release();

        }

#else

        destroy();

#endif

    }

}

FileHandleCache::FileHandleCache(size_t capacity, size_t num_partitions,

                                 uint64_t unused_handle_timeout_secs)

        : _cache_partitions(num_partitions),

          _unused_handle_timeout_secs(unused_handle_timeout_secs) {

    DCHECK_GT(num_partitions, 0);

    size_t remainder = capacity % num_partitions;

    size_t base_capacity = capacity / num_partitions;

    size_t partition_capacity = (remainder > 0 ? base_capacity + 1 : base_capacity);

    for (FileHandleCachePartition& p : _cache_partitions) {

        p.cache.set_capacity(partition_capacity);

    }

    Status st = init();

    if (!st) {

        LOG(FATAL) << "failed to start file handle cache thread: " << st.to_string();

    }

}

FileHandleCache::~FileHandleCache() {

    _is_shut_down.store(true);

    if (_eviction_thread != nullptr) {

        _eviction_thread->join();

    }

}

Status FileHandleCache::init() {

    return Thread::create("file-handle-cache", "File Handle Timeout",

                          &FileHandleCache::_evict_handles_loop, this, &_eviction_thread);

}

Status FileHandleCache::get_file_handle(const hdfsFS& fs, const std::string& fname, int64_t mtime,

                                        int64_t file_size, bool require_new_handle,

                                        FileHandleCache::Accessor* accessor, bool* cache_hit) {

    DCHECK_GE(mtime, 0);

    // Hash the key and get appropriate partition

    uintptr_t fs_identity = reinterpret_cast<uintptr_t>(fs);

    uint32_t seed = HashUtil::hash(&fs_identity, sizeof(fs_identity), 0);

    int index = HashUtil::hash(fname.data(), cast_set<int>(fname.size()), seed) %

                _cache_partitions.size();

    FileHandleCachePartition& p = _cache_partitions[index];

    auto cache_key = make_cache_key(fs, fname, mtime);

    // If this requires a new handle, skip to the creation codepath. Otherwise,

    // find an unused entry with the same mtime

    if (!require_new_handle) {

        auto cache_accessor = p.cache.get(cache_key);

        if (cache_accessor.get()) {

            // Found a handler in cache and reserved it

            *cache_hit = true;

            accessor->set(std::move(cache_accessor));

            return Status::OK();

        }

    }

    // There was no entry that was free or caller asked for a new handle

    *cache_hit = false;

    // Emplace a new file handle and get access

    auto accessor_tmp = p.cache.emplace_and_get(cache_key, fs, fname, mtime);

    // Opening a file handle requires talking to the NameNode so it can take some time.

    Status status = accessor_tmp.get()->init(file_size);

    if (UNLIKELY(!status.ok())) {

        // Removing the handler from the cache after failed initialization.

        accessor_tmp.destroy();

        return status;

    }

    // Moving the cache accessor to the in/out parameter

    accessor->set(std::move(accessor_tmp));

    return Status::OK();

}

#ifdef BE_TEST

bool FileHandleCache::same_cache_key_for_test(const hdfsFS& lhs_fs, const std::string& lhs_fname,

                                              int64_t lhs_mtime, const hdfsFS& rhs_fs,

                                              const std::string& rhs_fname, int64_t rhs_mtime) {

    return make_cache_key(lhs_fs, lhs_fname, lhs_mtime) ==

           make_cache_key(rhs_fs, rhs_fname, rhs_mtime);

}

#endif

void FileHandleCache::_evict_handles_loop() {

    while (!_is_shut_down.load()) {

        if (_unused_handle_timeout_secs) {

            for (FileHandleCachePartition& p : _cache_partitions) {

                uint64_t now = MonotonicSeconds();

                uint64_t oldest_allowed_timestamp =

                        now > _unused_handle_timeout_secs ? now - _unused_handle_timeout_secs : 0;

                p.cache.evict_older_than(oldest_allowed_timestamp);

            }

        }

        std::this_thread::sleep_for(std::chrono::milliseconds(1000));

    }

}

} // namespace doris::io