/*
 * Copyright 2018 The Android Open Source Project
 *
 * 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.
 */

#include "get_folder_items.h"

namespace bluetooth {
namespace avrcp {

std::unique_ptr<GetFolderItemsResponseBuilder>
GetFolderItemsResponseBuilder::MakePlayerListBuilder(Status status,
                                                     uint16_t uid_counter,
                                                     size_t mtu) {
  std::unique_ptr<GetFolderItemsResponseBuilder> builder(
      new GetFolderItemsResponseBuilder(Scope::MEDIA_PLAYER_LIST, status,
                                        uid_counter, mtu));

  return builder;
}

std::unique_ptr<GetFolderItemsResponseBuilder>
GetFolderItemsResponseBuilder::MakeVFSBuilder(Status status,
                                              uint16_t uid_counter,
                                              size_t mtu) {
  std::unique_ptr<GetFolderItemsResponseBuilder> builder(
      new GetFolderItemsResponseBuilder(Scope::VFS, status, uid_counter, mtu));

  return builder;
}

std::unique_ptr<GetFolderItemsResponseBuilder>
GetFolderItemsResponseBuilder::MakeNowPlayingBuilder(Status status,
                                                     uint16_t uid_counter,
                                                     size_t mtu) {
  std::unique_ptr<GetFolderItemsResponseBuilder> builder(
      new GetFolderItemsResponseBuilder(Scope::NOW_PLAYING, status, uid_counter,
                                        mtu));

  return builder;
}

size_t GetFolderItemsResponseBuilder::size() const {
  size_t len = BrowsePacket::kMinSize();
  len += 1;  // Status

  // There is nothing other than the status in the packet if the status isn't
  // NO_ERROR
  if (status_ != Status::NO_ERROR || items_.size() == 0) return len;

  len += 2;  // UID Counter
  len += 2;  // Number of Items;
  for (const auto& item : items_) {
    len += item.size();
  }

  return len;
}

bool GetFolderItemsResponseBuilder::Serialize(
    const std::shared_ptr<::bluetooth::Packet>& pkt) {
  ReserveSpace(pkt, size());

  BrowsePacketBuilder::PushHeader(pkt, size() - BrowsePacket::kMinSize());

  if (status_ == Status::NO_ERROR && items_.size() == 0) {
    // Return range out of bounds if there are zero items in the folder
    status_ = Status::RANGE_OUT_OF_BOUNDS;
  }

  AddPayloadOctets1(pkt, (uint8_t)status_);  // Status
  if (status_ != Status::NO_ERROR) return true;

  AddPayloadOctets2(pkt, base::ByteSwap(uid_counter_));
  uint16_t num_items = items_.size();
  AddPayloadOctets2(pkt, base::ByteSwap(num_items));

  for (const auto& item : items_) {
    PushMediaListItem(pkt, item);
  }

  return true;
}

bool GetFolderItemsResponseBuilder::AddMediaPlayer(MediaPlayerItem item) {
  CHECK(scope_ == Scope::MEDIA_PLAYER_LIST);

  if (size() + item.size() > mtu_) return false;

  items_.push_back(MediaListItem(item));
  return true;
}

bool GetFolderItemsResponseBuilder::AddSong(MediaElementItem item) {
  CHECK(scope_ == Scope::VFS || scope_ == Scope::NOW_PLAYING);

  if (size() + item.size() > mtu_) return false;

  items_.push_back(MediaListItem(item));
  return true;
}

bool GetFolderItemsResponseBuilder::AddFolder(FolderItem item) {
  CHECK(scope_ == Scope::VFS);

  if (size() + item.size() > mtu_) return false;

  items_.push_back(MediaListItem(item));
  return true;
}

void GetFolderItemsResponseBuilder::PushMediaListItem(
    const std::shared_ptr<::bluetooth::Packet>& pkt,
    const MediaListItem& item) {
  switch (item.type_) {
    case MediaListItem::PLAYER:
      PushMediaPlayerItem(pkt, item.player_);
      break;
    case MediaListItem::FOLDER:
      PushFolderItem(pkt, item.folder_);
      break;
    case MediaListItem::SONG:
      PushMediaElementItem(pkt, item.song_);
      break;
  }
}

void GetFolderItemsResponseBuilder::PushMediaPlayerItem(
    const std::shared_ptr<::bluetooth::Packet>& pkt,
    const MediaPlayerItem& item) {
  AddPayloadOctets1(pkt, 0x01);  // Media Player Item
  uint16_t item_len = item.size() - 3;
  AddPayloadOctets2(pkt, base::ByteSwap(item_len));  // Item length
  AddPayloadOctets2(pkt, base::ByteSwap(item.id_));  // Player ID
  AddPayloadOctets1(pkt, 0x01);                      // Player Type
  AddPayloadOctets4(pkt, 0x00000000);                // Player Subtype
  AddPayloadOctets1(
      pkt, 0x02);  // Player Play Status // TODO: Add this as a passed field

  // Features
  AddPayloadOctets1(pkt, 0x00);
  AddPayloadOctets1(pkt, 0x00);
  AddPayloadOctets1(pkt, 0x00);
  AddPayloadOctets1(pkt, 0x00);
  AddPayloadOctets1(pkt, 0x00);
  AddPayloadOctets1(pkt, 0xb7);
  AddPayloadOctets1(pkt, 0x01);
  if (item.browsable_) {
    AddPayloadOctets1(pkt, 0x0C);
    AddPayloadOctets1(pkt, 0x0a);
  } else {
    AddPayloadOctets1(pkt, 0x04);
    AddPayloadOctets1(pkt, 0x00);
  }
  AddPayloadOctets1(pkt, 0x00);
  AddPayloadOctets1(pkt, 0x00);
  AddPayloadOctets1(pkt, 0x00);
  AddPayloadOctets1(pkt, 0x00);
  AddPayloadOctets1(pkt, 0x00);
  AddPayloadOctets1(pkt, 0x00);
  AddPayloadOctets1(pkt, 0x00);

  AddPayloadOctets2(pkt, base::ByteSwap((uint16_t)0x006a));
  uint16_t name_len = item.name_.size();
  AddPayloadOctets2(pkt, base::ByteSwap(name_len));

  for (const uint8_t& byte : item.name_) {
    AddPayloadOctets1(pkt, byte);
  }
}

void GetFolderItemsResponseBuilder::PushFolderItem(
    const std::shared_ptr<::bluetooth::Packet>& pkt, const FolderItem& item) {
  AddPayloadOctets1(pkt, 0x02);  // Folder Item
  uint16_t item_len = item.size() - 3;
  AddPayloadOctets2(pkt, base::ByteSwap(item_len));
  AddPayloadOctets8(pkt, base::ByteSwap(item.uid_));
  AddPayloadOctets1(pkt, item.folder_type_);
  AddPayloadOctets1(pkt, item.is_playable_ ? 0x01 : 0x00);
  AddPayloadOctets2(pkt,
                    base::ByteSwap((uint16_t)0x006a));  // UTF-8 Character Set
  uint16_t name_len = item.name_.size();
  AddPayloadOctets2(pkt, base::ByteSwap(name_len));
  for (const uint8_t& byte : item.name_) {
    AddPayloadOctets1(pkt, byte);
  }
}

void GetFolderItemsResponseBuilder::PushMediaElementItem(
    const std::shared_ptr<::bluetooth::Packet>& pkt,
    const MediaElementItem& item) {
  AddPayloadOctets1(pkt, 0x03);  // Media Element Item
  uint16_t item_len = item.size() - 3;
  AddPayloadOctets2(pkt, base::ByteSwap(item_len));
  AddPayloadOctets8(pkt, base::ByteSwap(item.uid_));
  AddPayloadOctets1(pkt, 0x00);  // Media Type Audio
  AddPayloadOctets2(pkt,
                    base::ByteSwap((uint16_t)0x006a));  // UTF-8 Character Set
  uint16_t name_len = item.name_.size();
  AddPayloadOctets2(pkt, base::ByteSwap(name_len));
  for (const uint8_t& byte : item.name_) {
    AddPayloadOctets1(pkt, byte);
  }

  AddPayloadOctets1(pkt, (uint8_t)item.attributes_.size());
  for (const auto& entry : item.attributes_) {
    AddPayloadOctets4(pkt, base::ByteSwap((uint32_t)entry.attribute()));
    AddPayloadOctets2(pkt,
                      base::ByteSwap((uint16_t)0x006a));  // UTF-8 Character Set

    std::string attr_val = entry.value();
    uint16_t attr_len = attr_val.size();

    AddPayloadOctets2(pkt, base::ByteSwap(attr_len));
    for (const uint8_t& byte : attr_val) {
      AddPayloadOctets1(pkt, byte);
    }
  }
}

Scope GetFolderItemsRequest::GetScope() const {
  auto it = begin() + BrowsePacket::kMinSize();
  return static_cast<Scope>(*it);
}

uint32_t GetFolderItemsRequest::GetStartItem() const {
  auto it = begin() + BrowsePacket::kMinSize() + static_cast<size_t>(1);
  return it.extractBE<uint32_t>();
}

uint32_t GetFolderItemsRequest::GetEndItem() const {
  auto it = begin() + BrowsePacket::kMinSize() + static_cast<size_t>(5);
  return it.extractBE<uint32_t>();
}

uint8_t GetFolderItemsRequest::GetNumAttributes() const {
  auto it = begin() + BrowsePacket::kMinSize() + static_cast<size_t>(9);
  return *it;
}

std::vector<Attribute> GetFolderItemsRequest::GetAttributesRequested() const {
  auto it = begin() + BrowsePacket::kMinSize() + static_cast<size_t>(9);

  size_t number_of_attributes = it.extract<uint8_t>();
  std::vector<Attribute> attribute_list;

  // No attributes requested
  if (number_of_attributes == 0xFF) return attribute_list;

  // TODO: If the number of attributes equals 0, then all attributes are
  // requested right now thats handled in the service itself, but it'd be nice
  // to have this function return a vector with all the attributes

  for (size_t i = 0; i < number_of_attributes; i++) {
    attribute_list.push_back((Attribute)it.extractBE<uint32_t>());
  }

  return attribute_list;
}

bool GetFolderItemsRequest::IsValid() const {
  if (!BrowsePacket::IsValid()) return false;
  // The minimum size required to be valid
  if (size() < kMinSize()) return false;

  auto attr_count = GetNumAttributes();

  // No items requested
  if (attr_count == 0xFF) return true;

  auto attr_start = begin() + kMinSize();

  // Casting the int returned from end - attr_start should be fine. If an
  // overflow occurs we can definitly say the packet is invalid
  return (attr_count * sizeof(Attribute)) == (size_t)(end() - attr_start);
}

std::string GetFolderItemsRequest::ToString() const {
  std::stringstream ss;
  ss << "GetFolderItemsRequestPacket: " << std::endl;
  ss << "  └ PDU = " << GetPdu() << std::endl;
  ss << "  └ Length = " << GetLength() << std::endl;
  ss << "  └ Scope = " << GetScope() << std::endl;
  ss << "  └ Start Item = " << loghex(GetStartItem()) << std::endl;
  ss << "  └ End Item = " << loghex(GetEndItem()) << std::endl;
  ss << "  └ Attribute Count = " << loghex(GetNumAttributes()) << std::endl;

  ss << std::endl;

  return ss.str();
}

std::unique_ptr<GetFolderItemsRequestBuilder>
GetFolderItemsRequestBuilder::MakeBuilder(
    Scope scope, uint32_t start_item, uint32_t end_item,
    const std::set<Attribute>& requested_attrs) {
  std::unique_ptr<GetFolderItemsRequestBuilder> builder(
      new GetFolderItemsRequestBuilder(scope, start_item, end_item,
                                       requested_attrs));

  return builder;
}

size_t GetFolderItemsRequestBuilder::size() const {
  size_t len = GetFolderItemsRequest::kMinSize();
  len += requested_attrs_.size() * sizeof(Attribute);
  return len;
}

bool GetFolderItemsRequestBuilder::Serialize(
    const std::shared_ptr<::bluetooth::Packet>& pkt) {
  ReserveSpace(pkt, size());

  BrowsePacketBuilder::PushHeader(pkt, size() - BrowsePacket::kMinSize());

  AddPayloadOctets1(pkt, static_cast<uint8_t>(scope_));
  AddPayloadOctets4(pkt, base::ByteSwap(start_item_));
  AddPayloadOctets4(pkt, base::ByteSwap(end_item_));

  if (requested_attrs_.size() == 0) {
    // 0xFF is the value to signify that there are no attributes requested.
    AddPayloadOctets1(pkt, 0xFF);
    return true;
  }

  AddPayloadOctets1(pkt, requested_attrs_.size());
  for (const auto& attr : requested_attrs_) {
    AddPayloadOctets4(pkt, base::ByteSwap(static_cast<uint32_t>(attr)));
  }
  return true;
}

}  // namespace avrcp
}  // namespace bluetooth