#include <algorithm>  // Para std::sort
#include <fstream>    // Para std::ifstream e std::getline
#include <functional> // Para std::function
#include <iomanip>    // Para std::setw
#include <iostream>   // Para std::cout, std::endl
#include <string>     // Para std::string
#include <vector>     // Para std::vector

//===================================================================
//
// Tipos de dados especiais
//
//===================================================================

// Informações sobre uma pessoa.
struct Pessoa {
  int id;             // código de identificação
  std::string nome;   // nome
  std::string funcao; // função na empresa
  int ano_ingresso;   // ano de ingresso
};

// Tipos de ordenação de resultados
enum class Ordena { por_id, por_nome, por_funcao, por_ingresso };

//===================================================================
//
// Protótipos de funções usadas pelo main
//
//===================================================================

// Função que lê os dados dos colaboradores do arquivo especificado.
std::vector<Pessoa> le_colaboradores(std::string nome_arquivo);

// Função que mostra uma lista de pessoas numa ordem escolhida.
void mostra_colaboradores(std::vector<Pessoa> pessoas, Ordena ordem);

//===================================================================
//
// Programa principal
//
// 1. Lê os dados dos colaboradores.
// 2. Mostra a lista ordenada por id
// 3. Mostra a lista ordenada por nome
// 4. Mostra a lista ordenada por função
// 5. Mostra a lista ordenada por ano de ingresso
//===================================================================
int main(int, char *[]) {
  auto todos = le_colaboradores("funcionarios.dat");

  std::cout << "Por id:\n";
  mostra_colaboradores(todos, Ordena::por_id);

  std::cout << "Por nome:\n";
  mostra_colaboradores(todos, Ordena::por_nome);

  std::cout << "Por funcao:\n";
  mostra_colaboradores(todos, Ordena::por_funcao);

  std::cout << "Por ingresso:\n";
  mostra_colaboradores(todos, Ordena::por_ingresso);
}

//===================================================================
//
// Implementações de funções auxiliares
//
//===================================================================

//===================================================================
// Função que lê a informação de uma pessoa da stream de entrada is
Pessoa le_pessoa(std::istream &is);

// Função que lê os dados dos colaboradores do arquivo especificado.
std::vector<Pessoa> le_colaboradores(std::string nome_arquivo) {
  // Vetor para guardar os dados de todas as pessoas.
  std::vector<Pessoa> todos;

  // Abre o arquivo de dados especificado.
  std::ifstream dados(nome_arquivo);

  // Enquanto estiver dando certo a leitura e não terminou o arquivo.
  while (dados.good() && !dados.eof()) {
    // Lê uma nova pessoa.
    auto nova = le_pessoa(dados);
    // Se consegui ler, guarda no vetor.
    if (dados.good()) {
      todos.push_back(nova);
    }
  }
  return todos;
}

// Função que lê a informação de uma pessoa da stream de entrada is
Pessoa le_pessoa(std::istream &is) {
  Pessoa quem;  // Dados da pessoa a serem lidos.
  char virgula; // Um char para pular as vírgulas.

  // Lê o código de identificação.
  is >> quem.id;
  is >> virgula; // Pula uma vírgula.

  // Lê até vírgula, coloca em quem.nome.
  std::getline(is, quem.nome, ',');
  // Lê até vírgula, coloca em quem.função.
  std::getline(is, quem.funcao, ',');
  // Lê o ano de ingresso.
  is >> quem.ano_ingresso;

  return quem;
}

//===================================================================
// Um tipo que descreve uma função que compara a ordem de
// duas pessoas de acordo com algum critério.
using OrderFunction = std::function<bool(Pessoa const &, Pessoa const &)>;

// Função que retorna uma função para comparação, de acordo com o
// tipo de ordenação desejada.
OrderFunction funcao_comparacao(Ordena ordem);

// Função que mostra uma lista de pessoas numa ordem escolhida.
void mostra_colaboradores(std::vector<Pessoa> pessoas, Ordena ordem) {
  std::sort(begin(pessoas), end(pessoas), funcao_comparacao(ordem));
  for (auto pessoa : pessoas) {
    std::cout << std::setw(4) << pessoa.id << std::setw(30) << pessoa.nome
              << std::setw(20) << pessoa.funcao << std::setw(8)
              << pessoa.ano_ingresso << std::endl;
  }
}

// Função que retorna uma função para comparação, de acordo com o
// tipo de ordenação desejada.
OrderFunction funcao_comparacao(Ordena ordem) {
  // Declara a variável f como uma função que recebe um duas
  // struct de pessoas e retorna um bool (função de comparação)
  // true se a primeira é anterior à segunda, false caso contrário.
  OrderFunction f;

  // Cria uma função apropriada, de acordo com a ordem escolhida.
  switch (ordem) {
  case Ordena::por_id:
    f = [](Pessoa const &a, Pessoa const &b) { return a.id < b.id; };
    break;
  case Ordena::por_nome:
    f = [](Pessoa const &a, Pessoa const &b) { return a.nome < b.nome; };
    break;
  case Ordena::por_funcao:
    f = [](Pessoa const &a, Pessoa const &b) { return a.funcao < b.funcao; };
    break;
  case Ordena::por_ingresso:
    f = [](Pessoa const &a, Pessoa const &b) {
      return a.ano_ingresso < b.ano_ingresso;
    };
    break;
  }
  return f;
}