// Copyright 2024 Google LLC

//

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

#pragma once

#include "google3/host_commands.h"

#include "message_util.hpp"

#include <fmt/format.h>

#include <stdplus/raw.hpp>

#include <algorithm>

#include <chrono>

#include <condition_variable>

#include <cstdint>

#include <cstring>

#include <functional>

#include <iostream>

#include <mutex>

#include <optional>

#include <queue>

#include <thread>

#include <unordered_map>

constexpr int kTransactionBufferSize = 1024;

constexpr int kBufferReadTimeoutMs = 1000;

constexpr int kMaxReadBufferIterations = 35;

constexpr bool kDebug = false;

constexpr int kHothBufferSize = 4096;

constexpr int kRateLimiterMilliSeconds = 500;

constexpr int kTransactionTimeoutInMicroSec = 1000;

constexpr int kMaxFileSizeInBytes = 4 * 1024 * 1024; // 4 MB in bytes

constexpr int kAsyncWaitTimeInSeconds = 30;

constexpr int kHeartBeatUpperLimit = 25;

const std::string kSyslogFileNamePrefix = "/tmp/syslog_file_";

// This is required to get a read-offset that is guaranteed to be out of the

// Hoth buffer, thus clients can offset the write-buffer with a big-enough value

// and let Hoth point to the correct read-offset.

// Use the same value as the upstreamed libhoth/htool:

// https://github.com/google/libhoth/commit/e4827163741e0804f12ac96c81b8e97649be6795

constexpr uint32_t kReadOffsetTweak = 0x80000000;

namespace google

{

namespace hoth

{

namespace internal

{

enum class PublishType : uint8_t

{

    Stderr,

    File

};

/**

 * @brief Supports rate limit for a single threaded mechanism, where requests

 * are discarded when the elapsed time < rate limit time

 */

class RateLimiter

{

  public:

    explicit RateLimiter(int rateLimitInMilliseconds) :

        rateLimitInMilliseconds(rateLimitInMilliseconds)

    {

        std::chrono::hours one_day(24);

        std::chrono::steady_clock::time_point yesterday =

            std::chrono::steady_clock::now() - one_day;

        lastTimeStamp = yesterday;

    };

    bool allowedByLimiter()

    {

        auto now = std::chrono::steady_clock::now();

        auto timeElapsed = now - lastTimeStamp;

        if (timeElapsed > std::chrono::milliseconds(rateLimitInMilliseconds))

        {

            lastTimeStamp = now;

            return true;

        }

        return false;

    };

    std::chrono::steady_clock::time_point getTimeStamp()

    {

        return lastTimeStamp;

    }

  private:

    int rateLimitInMilliseconds;

    std::chrono::steady_clock::time_point lastTimeStamp;

};

class LogCollectorUtil

{

  public:

    LogCollectorUtil(RateLimiter& rateLimiter, int asyncWaitTime);

    ~LogCollectorUtil() = default;

    /**

     * @brief Generates a request for snapshotting hoth buffer

     *

     * @return request as a vector of bytes

     */

    static std::vector<uint8_t> generateSnapshotRequest();

    /**

     * @brief Generates a request for getting the snapshot of the hoth buffer

     *

     * @return request as a vector of bytes

     */

    static std::vector<uint8_t> generateGrabSnapshotRequest();

    /**

     * @brief Verifies the response header

     *

     * @return true or false (in terms of validity)

     */

    static bool isResponseValid(std::vector<uint8_t> response);

    /**

     * @brief Generates Collect Uart Request

     *

     * @param[in] channelId - Channel Id for Uart

     * @param[in] readOffset - Offset from where the buffer is to be read

     */

    static std::vector<uint8_t> generateCollectUartLogsRequest(

        uint32_t channelId, uint32_t readOffset);

    /**

     * @brief Publishes the snapshot based on publish type

     *

     * @param[in] response - Response vector

     * @param[in] publishType - Stderr or file

     * @param[in] filePathSuffix - File path name suffix if Publish type is file

     * @param[in] meta - If any meta data is to be printed in the logs

     *

     */

    static void publishSnapshot(

        std::vector<uint8_t> response, PublishType publishType,

        std::string_view filePathSuffix = "", std::string_view meta = "");

    /**

     * @brief Generate unique request id

     *

     * @return request id

     */

    int generateRequestId();

    /**

     * @brief Gets the wait time set during initialization

     *

     * @return wait time in seconds

     */

    int getAsyncWaitTime() const;

    /**

     * @brief Current request counter

     */

    int requestCounter = 0;

    /**

     * @brief Create GetChannelWriteOffset request

     *

     * @param[in] channelId - Unique channel id

     *

     * @return request bytes for channel write offset

     */

    static std::vector<uint8_t> generateGetChannelWriteOffsetRequest(

        const uint32_t& channelId);

    /**

     * @brief Writes to file

     *

     * @param[in] data - string of data to be dumped in a file

     * @param[in] name - suffix of the file name (gets attached to prefix -

     * "syslog_file")

     */

    static void writeToFile(std::string_view data, std::string_view name);

    /**

     * @brief Sends a heartbeat once every kHeartBeatLimit when invoked

     *

     * @param[in] data - Message for the heartbeat

     */

    static void heartbeat(std::string_view message);

    /**

     * @brief Rate Limits the requests to be sent to log collector

     */

    RateLimiter rateLimiter;

    /**

     * @brief Async wait timer for uart logs

     */

    int asyncWaitTime = 0;

};

} // namespace internal

} // namespace hoth

} // namespace google