// 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/cr51_image_descriptor.h"
#include "google3/host_commands.h"

#include "host_command.hpp"
#include "message_util.hpp"
#include "payload_update_interface.hpp"
#include "sys.hpp"

#include <stdplus/handle/managed.hpp>

#include <optional>
#include <span>
#include <string>
#include <vector>

namespace google
{
namespace hoth
{
namespace internal
{

// Struct used to send activate request:
struct ActivateRequest
{
    payload_update_packet header;
    payload_update_activate activate;
};

// Struct used to send confirm request:
struct ConfirmRequest
{
    payload_update_packet header;
    payload_update_confirm confirm;
};

// Maximum allowed payload size
constexpr size_t max_packet_size =
    mailbox_size - sizeof(payload_update_packet) - sizeof(ReqHeader);

constexpr size_t kImageDescriptorAlignment = 64 * 1024;

constexpr uint64_t kDescriptorMagic = 0x5f435344474d495f; // "_IMGDSC_"

constexpr uint32_t kSectorSizeBytes = 4096;
constexpr uint32_t kEraseChunkSizeBytes = kSectorSizeBytes * 32;

/** @class PayloadUpdateImpl
 *  @brief PayloadUpdate method implementation
 *  @details Methods to interface with Hoth to perform payload update
 */
class PayloadUpdateImpl : public PayloadUpdate
{
  public:
    explicit PayloadUpdateImpl(HostCommand* hostCmd,
                               const Sys* sys = &sys_impl) :
        hostCmd(hostCmd), sys(sys)
    {}

    void initiate() const override;
    void erase(uint32_t offset, uint32_t size) const override;
    void eraseAndSendStaticWP(const std::string& path) const override;
    void read(uint32_t offset, std::span<uint8_t> data) const override;
    void verify() const override;
    payload_update_status getStatus() const override;
    void activate(Side side, Persistence persistence) const override;
    void send(const std::string& imagePath) const override;
    std::optional<payload_update_confirm_response>
        confirm(enum payload_update_confirm_option option, uint32_t timeout,
                uint64_t confirmation_cookie) const override;
    bool findDescriptor(const std::string& path, uint32_t* desc_offset) const override;
    void eraseAndSendStaticWPRegions(const std::string& path,
                                     uint32_t desc_offset) const override;
    // Arbitrarily picked due to the performance of the calls taking ~0.4s
    static constexpr size_t verify_size = 512 * 1024;

  private:
    void sendCommand(uint8_t command, uint32_t offset = 0,
                     uint32_t len = 0) const;
    void sendCommand(std::span<const uint8_t> request) const;
    [[nodiscard]] std::span<const uint8_t>
        sendCommand(std::vector<uint8_t>& buf, uint8_t command,
                    uint32_t offset = 0, uint32_t len = 0) const;
    [[nodiscard]] std::span<const uint8_t>
        sendCommand(std::vector<uint8_t>& buf,
                    std::span<const uint8_t> request) const;
    void trimAndSend(std::span<const uint8_t> data,
                     uint32_t globalOffset) const;
    /** @brief RAII wrapper and its destructor for opening a file descriptor */
    static void closeFd(int&& fd, const Sys*& sys)
    {
        if (sys)
        {
            sys->close(fd);
        }
    }
    using Fd = stdplus::Managed<int, const Sys*>::Handle<closeFd>;

    /** @brief Connection to Hoth for sending and receiving host commands */
    HostCommand* hostCmd = nullptr;
    const Sys* sys = nullptr;
};

} // namespace internal

} // namespace hoth

} // namespace google