#include <cstddef>
#include <random>
#include <string>
#include <vector>

#include <book_store/book.hh>
#include <book_store/person.hh>
#include <book_store/random.hh>

namespace book_store::utility::random {
auto book_random_engine::title() -> std::string {
  static std::uniform_int_distribution<> distribution{0, 49};
  std::string book_name;

  for (int i = 0; i < 3; ++i) {
    book_name += book_title_parts[static_cast<std::size_t>(
        distribution(this->_random_number_generator))];
    book_name += ' ';
  }

  book_name.pop_back();

  return book_name;
}

auto book_random_engine::name() -> std::string {
  static std::uniform_int_distribution<> distribution{0, 49};

  return std::string(names[static_cast<std::size_t>(
      distribution(this->_random_number_generator))]);
}

auto book_random_engine::author() -> consumer::person {
  return consumer::person{this->name(), this->name(), this->id()};
}

auto book_random_engine::authors() -> std::vector<consumer::person> {
  std::vector<consumer::person> authors;
  static std::uniform_int_distribution<> distribution{1, 4};
  auto author_count = distribution(this->_random_number_generator);

  authors.reserve(static_cast<std::size_t>(author_count));

  for (int i = 0; i < author_count; ++i) {
    authors.push_back(this->author());
  }

  return authors;
}

auto book_random_engine::publisher() -> std::string {
  static std::uniform_int_distribution<> distribution{0, 9};

  return std::string(publishers[static_cast<std::size_t>(
      distribution(this->_random_number_generator))]);
}

auto book_random_engine::isbn() -> std::string {
  static std::uniform_int_distribution<> distribution{0, 9};
  std::string isbn;

  for (int i = 0; i < 13; ++i) {
    isbn += std::to_string(distribution(this->_random_number_generator));
  }

  return isbn;
}

auto book_random_engine::price_usd() -> double {
  static std::uniform_real_distribution<> distribution{0.0, 100.0};

  return distribution(this->_random_number_generator);
}

auto book_random_engine::copy_count() -> product::book::size_type {
  static std::uniform_int_distribution<> distribution{0, 10000};

  return static_cast<product::book::size_type::book_count_type>(
      distribution(this->_random_number_generator));
}

auto book_random_engine::id() -> std::size_t {
  static std::uniform_int_distribution<> distribution{0, 1000000};

  return static_cast<std::size_t>(distribution(this->_random_number_generator));
}
} // namespace book_store::utility::random