// Copyright 2021 The Pigweed Authors

//

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

//

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

#include "pw_bluetooth_hci/packet.h"

#include "pw_bytes/byte_builder.h"

#include "pw_bytes/endian.h"

#include "pw_status/try.h"

namespace pw::bluetooth_hci {

namespace {

using pw::bytes::ReadInOrder;

}  // namespace

Result<ConstByteSpan> CommandPacket::Encode(ByteSpan buffer,

                                            endian order) const {

  ByteBuilder builder(buffer);

  builder.PutUint16(opcode_, order);

  builder.PutUint8(parameters_.size_bytes());

  builder.append(parameters_);

  PW_TRY(builder.status());

  return ConstByteSpan(builder.data(), builder.size());

}

std::optional<CommandPacket> CommandPacket::Decode(ConstByteSpan data,

                                                   endian order) {

  if (data.size_bytes() < kHeaderSizeBytes) {

    return std::nullopt;  // Not enough data to parse the packet header.

  }

  const uint8_t parameter_total_length =

      static_cast<uint8_t>(data[kParameterTotalLengthByteOffset]);

  if (data.size_bytes() < (kHeaderSizeBytes + parameter_total_length)) {

    return std::nullopt;  // Not enough data to cover the parameter bytes.

  }

  const uint16_t opcode =

      ReadInOrder<uint16_t>(order, &data[kOpcodeByteOffset]);

  return CommandPacket(opcode,

                       data.subspan(kHeaderSizeBytes, parameter_total_length));

}

Result<ConstByteSpan> AsyncDataPacket::Encode(ByteSpan buffer,

                                              endian order) const {

  ByteBuilder builder(buffer);

  builder.PutUint16(handle_and_fragmentation_bits_, order);

  builder.PutUint16(data_.size_bytes(), order);

  builder.append(data_);

  PW_TRY(builder.status());

  return ConstByteSpan(builder.data(), builder.size());

}

std::optional<AsyncDataPacket> AsyncDataPacket::Decode(ConstByteSpan data,

                                                       endian order) {

  if (data.size_bytes() < kHeaderSizeBytes) {

    return std::nullopt;  // Not enough data to parse the packet header.

  }

  const uint16_t data_total_length =

      ReadInOrder<uint16_t>(order, &data[kDataTotalLengthByteOffset]);

  if (data.size_bytes() < (kHeaderSizeBytes + data_total_length)) {

    return std::nullopt;  // Not enough data to cover the data bytes.

  }

  const uint16_t handle_and_flag_bits = ReadInOrder<uint16_t>(

      order, &data[kHandleAndFragmentationBitsByteOffset]);

  return AsyncDataPacket(handle_and_flag_bits,

                         data.subspan(kHeaderSizeBytes, data_total_length));

}

Result<ConstByteSpan> SyncDataPacket::Encode(ByteSpan buffer,

                                             endian order) const {

  ByteBuilder builder(buffer);

  builder.PutUint16(handle_and_status_bits_, order);

  builder.PutUint8(data_.size_bytes());

  builder.append(data_);

  PW_TRY(builder.status());

  return ConstByteSpan(builder.data(), builder.size());

}

std::optional<SyncDataPacket> SyncDataPacket::Decode(ConstByteSpan data,

                                                     endian order) {

  if (data.size_bytes() < kHeaderSizeBytes) {

    return std::nullopt;  // Not enough data to parse the packet header.

  }

  const uint8_t data_total_length =

      static_cast<uint8_t>(data[kDataTotalLengthByteOffset]);

  if (data.size_bytes() < (kHeaderSizeBytes + data_total_length)) {

    return std::nullopt;  // Not enough data to cover the data bytes.

  }

  const uint16_t handle_and_status_bits =

      ReadInOrder<uint16_t>(order, &data[kHandleAndStatusBitsByteOffset]);

  return SyncDataPacket(handle_and_status_bits,

                        data.subspan(kHeaderSizeBytes, data_total_length));

}

Result<ConstByteSpan> EventPacket::Encode(ByteSpan buffer) const {

  ByteBuilder builder(buffer);

  builder.PutUint8(event_code_);

  builder.PutUint8(parameters_.size_bytes());

  builder.append(parameters_);

  PW_TRY(builder.status());

  return ConstByteSpan(builder.data(), builder.size());

}

std::optional<EventPacket> EventPacket::Decode(ConstByteSpan data) {

  if (data.size_bytes() < kHeaderSizeBytes) {

    return std::nullopt;  // Not enough data to parse the packet header.

  }

  const uint8_t parameter_total_length =

      static_cast<uint8_t>(data[kParameterTotalLengthByteOffset]);

  if (data.size_bytes() < (kHeaderSizeBytes + parameter_total_length)) {

    return std::nullopt;  // Not enough data to cover the parameter bytes.

  }

  const uint8_t event_code = static_cast<uint8_t>(data[kEventCodeByteOffset]);

  return EventPacket(event_code,

                     data.subspan(kHeaderSizeBytes, parameter_total_length));

}

}  // namespace pw::bluetooth_hci