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

#pragma once

#include <future>

#include <memory>

#include "common/status.h"

#include "io/cache/block_file_cache.h"

#include "io/cache/block_file_cache_factory.h"

#include "io/cache/file_cache_common.h"

#include "io/fs/file_reader_writer_fwd.h"

#include "io/fs/packed_slice_location.h"

#include "io/fs/path.h"

#include "util/slice.h"

namespace doris::io {

class FileSystem;

struct FileCacheAllocatorBuilder;

struct EncryptionInfo;

// Only affects remote file writers

struct FileWriterOptions {

    // BE stages every file as an uncompleted upload (S3 multipart parts or Azure blocks), and

    // the FE coordinator completes them at commit. An uncompleted file is not visible, so a

    // single file is atomic. Multiple files are still not atomic, but because Hive committers

    // have best-effort semantics, this shortens the inconsistent time window.

    // The coordinator must support the client's ObjStorageCapabilities::deferred_completion.

    bool deferred_completion = false;

    bool write_file_cache = false;

    bool allow_adaptive_file_cache_write = true;

    bool is_cold_data = false;

    bool sync_file_data = true;              // Whether flush data into storage system

    uint64_t file_cache_expiration_time = 0; // Absolute time, 0 means no TTL

    uint64_t approximate_bytes_to_write = 0; // Approximate bytes to write, used for file cache

};

struct AsyncCloseStatusPack {

    std::promise<Status> promise;

    std::future<Status> future;

};

class FileWriter {

public:

    enum class State : uint8_t {

        OPENED = 0,

        ASYNC_CLOSING,

        CLOSED,

    };

    FileWriter() = default;

    virtual ~FileWriter() = default;

    FileWriter(const FileWriter&) = delete;

    const FileWriter& operator=(const FileWriter&) = delete;

    // Normal close. Wait for all data to persist before returning.

    // If there is no data appended, an empty file will be persisted.

    virtual Status close(bool non_block = false) = 0;

    // Non-blocking probe for a previous close(true).

    // OK means close finished successfully. NeedSendAgain means close is still running.

    // Other errors mean close finished with error or the writer does not support this API.

    // NOTE: This method consumes the async close result when it is ready. The caller must

    // use it as the only completion path for that async close; mixing it with close(false)

    // or another try_finish_close consumer is not supported.

    virtual Status try_finish_close() {

        return Status::NotSupported("try_finish_close is not supported");

    }

    Status append(const Slice& data) { return appendv(&data, 1); }

    virtual Status appendv(const Slice* data, size_t data_cnt) = 0;

    virtual const Path& path() const = 0;

    virtual size_t bytes_appended() const = 0;

    virtual State state() const = 0;

    // Gets the location of this file's slice in the packed file. Must be called after the writer

    // is closed. An empty packed_file_path means the file is not in a packed file. Writers that

    // wrap another writer must forward this call, so callers never need to downcast to

    // PackedFileWriter.

    virtual Status get_packed_slice_location(PackedSliceLocation* location) const {

        *location = PackedSliceLocation {};

        return Status::OK();

    }

    FileCacheAllocatorBuilder* cache_builder() const {

        return _cache_builder == nullptr ? nullptr : _cache_builder.get();

    }

protected:

    void init_cache_builder(const FileWriterOptions* opts, const Path& path) {

        if (!config::enable_file_cache || opts == nullptr) {

            return;

        }

        io::UInt128Wrapper path_hash = BlockFileCache::hash(path.filename().native());

        BlockFileCache* file_cache_ptr = FileCacheFactory::instance()->get_by_path(path_hash);

        bool has_enough_file_cache_space = opts->allow_adaptive_file_cache_write &&

                                           config::enable_file_cache_adaptive_write &&

                                           (opts->approximate_bytes_to_write > 0) &&

                                           (file_cache_ptr->approximate_available_cache_size() >

                                            opts->approximate_bytes_to_write);

        VLOG_DEBUG << "path:" << path.filename().native()

                   << ", write_file_cache:" << opts->write_file_cache

                   << ", allow_adaptive_file_cache_write:" << opts->allow_adaptive_file_cache_write

                   << ", has_enough_file_cache_space:" << has_enough_file_cache_space

                   << ", approximate_bytes_to_write:" << opts->approximate_bytes_to_write

                   << ", file_cache_available_size:"

                   << file_cache_ptr->approximate_available_cache_size();

        if (opts->write_file_cache || has_enough_file_cache_space) {

            _cache_builder = std::make_unique<FileCacheAllocatorBuilder>(FileCacheAllocatorBuilder {

                    opts ? opts->is_cold_data : false, opts ? opts->file_cache_expiration_time : 0,

                    path_hash, file_cache_ptr});

        }

        return;

    }

    std::unique_ptr<FileCacheAllocatorBuilder> _cache_builder =

            nullptr; // nullptr if disable write file cache

};

} // namespace doris::io