#include "controleSalva.

hpp"
#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <algorithm>
#include <fstream>
#include <sstream>

Pessoa::Pessoa(std::string nome, std::string email, std::string senha)

: nome(nome), email(email), senha(senha) {}

std::string Pessoa::getNome() const {

return nome;
}

std::string Pessoa::getEmail() const {

return email;
}

std::string Pessoa::verSenha() const {

return senha;
}

void Pessoa::alterarEmail(const std::string& novoEmail) {

email = novoEmail;
}

void Pessoa::alterarSenha(const std::string& novaSenha) {

senha = novaSenha;
}

void Pessoa::exibirInformacoes() const {

std::cout << "Nome: " << nome << "\nEmail: " << email << std::endl;
}

Pessoa::~Pessoa() {}

Aluno::Aluno(std::string nome, std::string email, std::string senha, int matricula,

std::string curso)
: Pessoa(nome, email, senha), matricula(matricula), curso(curso) {}

void Aluno::consultarNotas() const {

for (const auto& [turma, nota] : notas) {
std::cout << "Turma: " << turma << ", Nota: " << nota << "\n";
}
}

void Aluno::consultarFrequencia() const {

for (const auto& [turma, frequencia] : frequencias) {
std::cout << "Turma: " << turma << ", Frequencia: " << frequencia << "%\n";
}
}

void Aluno::exibirInformacoes() const {

std::cout << "Nome: " << nome << "\nEmail: " << email << "\nCurso: " << curso
<< "\nMatricula: " << matricula << "\n";
std::cout << "Turmas:\n";
for (const auto& turma : turmas) {
 std::cout << "- " << turma->getCodigo() << " (" << turma->getDisciplina()
<< ")\n";
}
}

void Aluno::adicionarNota(Turma* turma, double nota) {

notas[turma->getCodigo()] = nota;
}

void Aluno::adicionarFrequencia(Turma* turma, double frequencia) {

frequencias[turma->getCodigo()] = frequencia;
}

void Aluno::adicionarTurma(Turma* turma) {

if (std::find(turmas.begin(), turmas.end(), turma) == turmas.end()) {
turmas.push_back(turma);
std::cout << "Turma " << turma->getCodigo() << " adicionada ao aluno " <<
nome << ".\n";
} else {
std::cout << "O aluno ja esta matriculado na turma " << turma->getCodigo()
<< ".\n";
}
}

bool Aluno::removerTurma(const std::string& codigoTurma) {

auto it = std::find_if(turmas.begin(), turmas.end(), [&](Turma* turma) {
return turma->getCodigo() == codigoTurma;
});

if (it != turmas.end()) {
turmas.erase(it);
std::cout << "Turma " << codigoTurma << " removida do aluno " << nome <<
".\n";
return true;
} else {
std::cout << "O aluno nao esta matriculado na turma " << codigoTurma << ".\
n";
return false;
}
}

void Aluno::listarTurmas() const {

std::cout << "Turmas do aluno " << nome << ":\n";
for (const auto& turma : turmas) {
std::cout << "- " << turma->getCodigo() << " (" << turma->getDisciplina()
<< ")\n";
}
}

int Aluno::getMatricula() const {

return matricula;
}

std::string Aluno::getCurso() const {

return curso;
}

std::string Aluno::stringMatricula() const {

return std::to_string(matricula);
}

const std::vector<Turma*>& Aluno::getTurmas() const {

return turmas;
}

std::map<std::string, double> Aluno::getNotas() const {

return notas;
};
std::map<std::string, double> Aluno::getFrequencias() const{
return frequencias;
};

Turma::Turma(std::string codigo, std::string disciplina, Professor* professor, int

numero_alunos)
: codigo(codigo), disciplina(disciplina), professor(professor),
numero_alunos(numero_alunos) {}

void Turma::adicionaAluno(int n) {
numero_alunos += n;
}

void Turma::removeAluno(int n) {
if (numero_alunos >= n) {
numero_alunos -= n;
} else {
std::cout << "Erro: numero de alunos insuficiente para remocao.\n";
}
}

void Turma::alteraCodigo(const std::string& novoCodigo) {

codigo = novoCodigo;
}

void Turma::alteraProfessor(Professor* novoProfessor) {

professor->removerTurma(codigo);
professor = novoProfessor;
}

void Turma::adicionarAluno(const Aluno& aluno) {

alunos.push_back(aluno);
adicionaAluno();
}

bool Turma::removerAlunoPorMatricula(int matricula) {

for (auto it = alunos.begin(); it != alunos.end(); ++it) {
if (it->getMatricula() == matricula) {
alunos.erase(it);
removeAluno();
return true;
}
}
std::cout << "Aluno com matricula " << matricula << " nao encontrado.\n";
return false;
}

bool Turma::isAlunoMatriculado(int matricula) const {

for (const auto& aluno : alunos) {
if (aluno.getMatricula() == matricula) {
 return true;
}
}
return false;
}

void Turma::exibirInformacoes() const {

std::cout << "Codigo: " << codigo << "\n";
std::cout << "Disciplina: " << disciplina << "\n";
std::cout << "Professor: " << professor->getNome() << "\n"; // Exibe o nome do
professor
std::cout << "Numero de alunos: " << numero_alunos << "\n";
std::cout << "Lista de alunos:\n";
for (const auto& aluno : alunos) {
aluno.exibirInformacoes();
std::cout << "----------------------\n";
}
}

std::string Turma::getCodigo() const {

return codigo;
}

std::string Turma::getDisciplina() const {

return disciplina;
}

std::string Turma::getNomeDisciplina() const {

return disciplina;
}

Professor* Turma::getProfessor() const {

return professor; // Retorna o ponteiro para o professor
}

std::vector<Aluno> Turma::getAlunos() const {

return alunos;
};

void Professor::adicionarTurma(Turma* turma) {

if (std::find(turmas.begin(), turmas.end(), turma) == turmas.end()) {
turmas.push_back(turma);
std::cout << "Turma " << turma->getCodigo() << " adicionada ao professor "
<< nome << ".\n";
} else {
std::cout << "O professor ja esta matriculado na turma " << turma-
>getCodigo() << ".\n";
}
}

bool Professor::removerTurma(const std::string& codigoTurma) {

auto it = std::find_if(turmas.begin(), turmas.end(), [&](Turma* turma) {
return turma->getCodigo() == codigoTurma;
});

if (it != turmas.end()) {
turmas.erase(it);
std::cout << "Turma " << codigoTurma << " removida do professor " << nome
<< ".\n";
 return true;
} else {
std::cout << "O professor nao esta matriculado na turma " << codigoTurma <<
".\n";
return false;
}
}

void Professor::listarTurmas() const {

if (turmas.empty()) {
std::cout << "Nao ha turmas associadas ao professor.\n";
return;
}

std::cout << "Turmas lecionadas por " << nome << ":\n";
for (const auto& turma : turmas) {
std::cout << "- Codigo: " << turma->getCodigo() << "\n";
}
}

bool Professor::registrarAlunoNaTurma(Aluno& aluno, const std::string& codigoTurma)

{
for (auto& turma : turmas) {
if (turma->getCodigo() == codigoTurma) {
turma->adicionarAluno(aluno);
aluno.adicionarTurma(turma);
std::cout << "Aluno " << aluno.getNome() << " registrado na turma " <<
codigoTurma << ".\n";
return true;
}
}
std::cout << "Erro: Turma " << codigoTurma << " nao encontrada ou o professor
nao leciona essa turma.\n";
return false;
}

bool Professor::registrarNotaAluno(Aluno& aluno, Turma* turma, double nota) {

// Verifica se o professor leciona a turma
if (std::find(turmas.begin(), turmas.end(), turma) == turmas.end()) {
std::cout << "Erro: O professor n�o leciona a turma " << turma->getCodigo()
<< ".\n";
return false;
}

// Verifica se o aluno est� matriculado na turma

if (!turma->isAlunoMatriculado(aluno.getMatricula())) {
std::cout << "Erro: O aluno nao esta matriculado na turma " << turma-
>getCodigo() << ".\n";
return false;
}

// Registra a nota
aluno.adicionarNota(turma, nota);
std::cout << "Nota " << nota << " registrada para o aluno " << aluno.getNome()
<< " na turma " << turma->getCodigo() << ".\n";
return true;
}

bool Professor::registrarFrequenciaAluno(Aluno& aluno, Turma* turma, double

frequencia) {
// Verifica se o professor leciona a turma
if (std::find(turmas.begin(), turmas.end(), turma) == turmas.end()) {
std::cout << "Erro: O professor nao leciona a turma " << turma->getCodigo()
<< ".\n";
return false;
}

// Verifica se o aluno est� matriculado na turma

if (!turma->isAlunoMatriculado(aluno.getMatricula())) {
std::cout << "Erro: O aluno n�o esta matriculado na turma " << turma-
>getCodigo() << ".\n";
return false;
}

// Registra a frequ�ncia
aluno.adicionarFrequencia(turma, frequencia);
std::cout << "Frequencia de " << frequencia << "% registrada para o aluno "
<< aluno.getNome() << " na turma " << turma->getCodigo() << ".\n";
return true;
}

void Professor::exibirInformacoes() const {

Pessoa::exibirInformacoes();
std::cout << "ID: " << id << std::endl;
listarTurmas();
}

// Construtor
Administrador::Administrador(std::string nome, std::string email, std::string
senha, std::string codigoAdm)
: Pessoa(nome, email, senha), codigoAdm(codigoAdm) {}

// Exibir informa��es do administrador

void Administrador::exibirInformacoes() const {
Pessoa::exibirInformacoes();
std::cout << "Codigo do Administrador: " << codigoAdm << std::endl;
}

// Retornar o c�digo do administrador

std::string Administrador::getCodigoAdm() const {
return codigoAdm;
}

// M�todos para gerenciamento de turmas e disciplinas

void Administrador::adicionarDisciplina(Curso& curso, const std::string&
nomeDisciplina) {
curso.adicionarDisciplina(nomeDisciplina);
}

void Administrador::removerDisciplina(Curso& curso, const std::string&

nomeDisciplina) {
curso.removerTurmaPorCodigo(nomeDisciplina);
}

void Administrador::adicionarTurma(Disciplina& disciplina, Turma* turma) {

disciplina.adicionarTurma(turma);
}
void Administrador::removerTurma(Disciplina& disciplina, const std::string&
codigoTurma) {
disciplina.removerTurmaPorCodigo(codigoTurma);
}

// Construtor
Disciplina::Disciplina(std::string nome)
: nome(nome), numero_turmas(0) {}

// Adicionar uma turma � disciplina

void Disciplina::adicionarTurma(Turma* turma) {
turmas.push_back(turma);
numero_turmas++;
}

// Remover uma turma da disciplina pelo c�digo

bool Disciplina::removerTurmaPorCodigo(const std::string& codigo) {
for (auto it = turmas.begin(); it != turmas.end(); ++it) {
if ((*it)->getCodigo() == codigo) {
turmas.erase(it);
numero_turmas--;
return true;
}
}
std::cout << "Turma com codigo " << codigo << " nao encontrada.\n";
return false;
}

// Exibir informa��es da disciplina e suas turmas

void Disciplina::exibirInformacoes() const {
std::cout << "Nome da Disciplina: " << nome << "\nNumero de Turmas: " <<
numero_turmas << "\n";
std::cout << "Lista de Turmas:\n";
for (const auto& turma : turmas) {
turma->exibirInformacoes();
std::cout << "----------------------\n";
}
}

// M�todos de acesso
std::string Disciplina::getNome() const { return nome; }
std::vector<Turma*> Disciplina::getTurmas() const { return turmas; }

// Construtor
Curso::Curso(std::string nome, std::string descricao)
: nome(nome), descricao(descricao), numero_disciplinas(0) {}

// Adicionar uma disciplina ao curso

void Curso::adicionarDisciplina(std::string nome_disciplina) {
Disciplina* disciplina = new Disciplina(nome_disciplina);
disciplinas.push_back(disciplina);
numero_disciplinas++;
}

// Remover uma disciplina do curso

bool Curso::removerTurmaPorCodigo(const std::string& nome) {
for (auto it = disciplinas.begin(); it != disciplinas.end(); ++it) {
if ((*it)->getNome() == nome) {
delete *it; // Libera mem�ria da disciplina
 disciplinas.erase(it);
numero_disciplinas--;
return true;
}
}
std::cout << "Disciplina com nome " << nome << " nao encontrada.\n";
return false;
}

// Exibir informa��es do curso e suas disciplinas

void Curso::exibirInformacoes() const {
std::cout << "Nome do Curso: " << nome << "\nCurso: " << nome
<< "\nNumero de Disciplinas: " << numero_disciplinas << "\n";
std::cout << "Lista de Disciplinas:\n";
for (const auto& disciplina : disciplinas) {
disciplina->exibirInformacoes();
std::cout << "----------------------\n";
}
}

// M�todos de acesso
std::string Curso::getNome() const { return nome; }
std::vector<Disciplina*> Curso::getDisciplinas() const { return disciplinas; }
std::string Curso:: getDescricao() const{ return descricao;}

// M�todos para adicionar objetos

void Escola::adicionarAluno(const Aluno& aluno) {
alunos.push_back(aluno);
}

void Escola::adicionarProfessor(const Professor& professor) {

professores.push_back(professor);
}

void Escola::adicionarAdministrador(const Administrador& administrador) {

administradores.push_back(administrador);
}

void Escola::adicionarCurso(const Curso& curso) {

cursos.push_back(curso);
}

// M�todos para encontrar objetos

Aluno* Escola::encontrarAluno(int matricula, const std::string& senha) {
for (auto& aluno : alunos) {
if (aluno.getMatricula() == matricula && aluno.verSenha() == senha) {
return &aluno;
}
}
return nullptr;
}

Aluno* Escola::retornarAluno(int matricula) {

for (auto& aluno : alunos) {
if (aluno.getMatricula() == matricula) {
return &aluno;
}
}
return nullptr;
}

Professor* Escola::encontrarProfessor(const std::string& id, const std::string&

senha) {
for (auto& professor : professores) {
if (professor.getId() == id && professor.verSenha() == senha) {
return &professor;
}
}
return nullptr;
}

Professor* Escola::retornarProfessor(const std::string& id) {

for (auto& professor : professores) {
if (professor.getId() == id) {
return &professor;
}
}
return nullptr;
}

Administrador* Escola::encontrarAdministrador(const std::string& codigo, const

std::string& senha) {
for (auto& admin : administradores) {
if (admin.getCodigoAdm() == codigo && admin.verSenha() == senha) {
return &admin;
}
}
return nullptr;
}

// M�todos para obter listas

std::vector<Aluno>& Escola::getAlunos() {
return alunos;
}

std::vector<Curso>& Escola::getCursos() {
return cursos;
}

// M�todos para encontrar objetos adicionais

Curso* Escola::encontrarCurso(const std::string& nomeCurso) {
for (auto& curso : cursos) {
if (curso.getNome() == nomeCurso) {
return &curso;
}
}
return nullptr; // Retorna nullptr se o curso n�o for encontrado
}

Disciplina* Escola::encontrarDisciplina(const std::string& nomeCurso, const

std::string& nomeDisciplina) {
Curso* curso = encontrarCurso(nomeCurso);
if (curso) {
for (auto& disciplina : curso->getDisciplinas()) {
if (disciplina->getNome() == nomeDisciplina) {
return disciplina;
}
}
 }
return nullptr; // Retorna nullptr se a disciplina n�o for encontrada
}

Turma* Escola::encontrarTurma(const std::string& nomeCurso, const std::string&

nomeDisciplina, const std::string& codigoTurma) {
// Encontra o curso
Curso* curso = encontrarCurso(nomeCurso);
if (curso) {
// Encontra a disciplina dentro do curso
Disciplina* disciplina = encontrarDisciplina(nomeCurso, nomeDisciplina);
if (disciplina) {
// Procura pela turma dentro da disciplina
for (auto& turma : disciplina->getTurmas()) {
if (turma->getCodigo() == codigoTurma) {
return turma;
}
}
}
}
return nullptr; // Retorna nullptr se a turma n�o for encontrada
}

void Escola::salvarAlunos(std::ofstream& arquivo) {

arquivo << "[Alunos]\n";
for (const auto& aluno : alunos) {
// Salvar informa��es b�sicas do aluno
arquivo << aluno.getNome() << ","
<< aluno.getEmail() << ","
<< aluno.verSenha() << "," // Senha armazenada
<< aluno.getMatricula() << ","
<< aluno.getCurso();

// Salvar turmas do aluno

for (const auto& turma : aluno.getTurmas()) {
arquivo << "," << turma->getCodigo();
}
arquivo << "\n";

// Salvar notas do aluno

arquivo << "[Notas]\n";
for (const auto& [codigoTurma, nota] : aluno.getNotas()) {
arquivo << aluno.getMatricula() << "," << codigoTurma << "," << nota <<
"\n";
}

// Salvar frequ�ncias do aluno

arquivo << "[Frequencias]\n";
for (const auto& [codigoTurma, frequencia] : aluno.getFrequencias()) {
arquivo << aluno.getMatricula() << "," << codigoTurma << "," <<
frequencia << "\n";
}
}
}

void Escola::salvarProfessores(std::ofstream& arquivo) {

arquivo << "[Professores]\n";
for (const auto& professor : professores) {
// Salvar informa��es b�sicas do professor
 arquivo << professor.getNome() << ","
<< professor.getEmail() << ","
<< professor.verSenha() << "," // Salvar senha
<< professor.getId();

// Salvar turmas associadas ao professor

for (const auto& turma : professor.getTurmas()) {
arquivo << "," << turma->getCodigo();
}
arquivo << "\n";
}
}

void Escola::salvarTurmas(std::ofstream& arquivo) {

arquivo << "[Turmas]\n";
for (const auto& curso : cursos) {
for (const auto& disciplina : curso.getDisciplinas()) {
for (const auto& turma : disciplina->getTurmas()) {
arquivo << turma->getCodigo() << "," << turma->getDisciplina() <<
","
<< turma->getProfessor()->getId() << "," << turma-
>getAlunos().size();

// Salvar alunos da turma

for (const auto& aluno : turma->getAlunos()) {
arquivo << "," << aluno.getMatricula();
}
arquivo << "\n";
}
}
}
}

void Escola::salvarCursos(std::ofstream& arquivo) {

arquivo << "[Cursos]\n";
for (const auto& curso : cursos) {
arquivo << curso.getNome() << "," << curso.getDescricao();

// Salvar disciplinas do curso

for (const auto& disciplina : curso.getDisciplinas()) {
arquivo << "," << disciplina->getNome();
}
arquivo << "\n";
}
}

void Escola::carregarDados(const std::string& nomeArquivo) {

std::ifstream arquivo(nomeArquivo);
if (!arquivo.is_open()) {
std::cerr << "Erro ao abrir o arquivo para carregar os dados.\n";
return;
}

std::string linha;
std::string secaoAtual;
std::map<std::string, Turma*> turmasCarregadas; // Mapa para armazenar turmas
temporariamente

// Armazenar cursos e disciplinas temporariamente para associar depois

std::map<std::string, Curso*> cursosCarregados;
std::map<std::string, Disciplina*> disciplinasCarregadas;

while (std::getline(arquivo, linha)) {

if (linha.empty()) continue;

if (linha[0] == '[') {
// Identificar a se��o atual
secaoAtual = linha;
} else if (secaoAtual == "[Alunos]") {
// Carregar alunos (sem turmas)
std::istringstream stream(linha);
std::string nome, email, senha, matriculaStr, curso;
std::getline(stream, nome, ',');
std::getline(stream, email, ',');
std::getline(stream, senha, ',');
std::getline(stream, matriculaStr, ',');
std::getline(stream, curso, ',');

int matricula = std::stoi(matriculaStr);

Aluno aluno(nome, email, senha, matricula, curso);

// Adicionar aluno � lista de alunos

alunos.push_back(aluno);
} else if (secaoAtual == "[Notas]") {
// Carregar notas
std::istringstream stream(linha);
std::string matriculaStr, codigoTurma, notaStr;
std::getline(stream, matriculaStr, ',');
std::getline(stream, codigoTurma, ',');
std::getline(stream, notaStr, ',');

int matricula = std::stoi(matriculaStr);

double nota = std::stod(notaStr);

// Buscar curso e disciplina da turma

std::string nomeCurso, nomeDisciplina;
std::getline(stream, nomeCurso, ',');
std::getline(stream, nomeDisciplina, ',');

Aluno* aluno = retornarAluno(matricula);

Turma* turma = encontrarTurma(nomeCurso, nomeDisciplina, codigoTurma);
if (aluno && turma) {
aluno->adicionarNota(turma, nota);
}
} else if (secaoAtual == "[Frequencias]") {
// Carregar frequ�ncias
std::istringstream stream(linha);
std::string matriculaStr, codigoTurma, frequenciaStr;
std::getline(stream, matriculaStr, ',');
std::getline(stream, codigoTurma, ',');
std::getline(stream, frequenciaStr, ',');

int matricula = std::stoi(matriculaStr);

double frequencia = std::stod(frequenciaStr);

// Buscar curso e disciplina da turma

std::string nomeCurso, nomeDisciplina;
std::getline(stream, nomeCurso, ',');
 std::getline(stream, nomeDisciplina, ',');

Aluno* aluno = retornarAluno(matricula);

Turma* turma = encontrarTurma(nomeCurso, nomeDisciplina, codigoTurma);
if (aluno && turma) {
aluno->adicionarFrequencia(turma, frequencia);
}
} else if (secaoAtual == "[Professores]") {
// Carregar professores
std::istringstream stream(linha);
std::string nome, email, senha, id, turma;
std::getline(stream, nome, ',');
std::getline(stream, email, ',');
std::getline(stream, senha, ',');
std::getline(stream, id, ',');

Professor professor(nome, email, senha, id);

// Adicionar professor � lista de professores

professores.push_back(professor);
} else if (secaoAtual == "[Turmas]") {
// Carregar turmas
std::istringstream stream(linha);
std::string codigo, disciplina, idProfessor, numeroAlunosStr,
matriculaAluno;
std::getline(stream, codigo, ',');
std::getline(stream, disciplina, ',');
std::getline(stream, idProfessor, ',');
std::getline(stream, numeroAlunosStr, ',');

int numeroAlunos = std::stoi(numeroAlunosStr);

Professor* professor = retornarProfessor(idProfessor);

// Primeiro, carregar a disciplina e associar

Disciplina* disciplinaObj = disciplinasCarregadas[disciplina];
if (!disciplinaObj) {
// Criar nova disciplina se n�o existir
disciplinaObj = new Disciplina(disciplina);
disciplinasCarregadas[disciplina] = disciplinaObj;
}

// Agora carregar a turma com a disciplina associada

Turma* turma = new Turma(codigo, disciplina, professor, numeroAlunos);

// Associe a turma � disciplina

disciplinaObj->adicionarTurma(turma);

// Salvar turma no mapa para posterior associa��o

turmasCarregadas[codigo] = turma;
} else if (secaoAtual == "[Cursos]") {
// Carregar cursos
std::istringstream stream(linha);
std::string nome, descricao;
std::getline(stream, nome, ',');
std::getline(stream, descricao, ',');

Curso curso(nome, descricao);

// Adicionar curso � lista de cursos

 cursos.push_back(curso);
cursosCarregados[nome] = &cursos.back();
}
}

for (auto& aluno : alunos) {

for (const auto& turma : aluno.getTurmas()) { // Itera sobre as turmas
associadas ao aluno
std::string turmaCodigo = turma->getCodigo(); // Pega o c�digo da
turma

auto it = turmasCarregadas.find(turmaCodigo); // Busca a chave, que �

o c�digo da turma
if (it != turmasCarregadas.end()) {
Turma* turmaEncontrada = it->second; // Recupera o ponteiro Turma
aluno.adicionarTurma(turmaEncontrada); // Associa a turma ao aluno
} else {
std::cerr << "Turma " << turmaCodigo << " n�o encontrada para o
aluno " << aluno.getNome() << ".\n";
}
}
}

// Associar turmas aos professores

for (auto& professor : professores) {
for (auto& turma : turmasCarregadas) {
if (turma.second->getProfessor()->getId() == professor.getId()) { //
Compare pelo ID do professor
professor.adicionarTurma(turma.second);
}
}
}

arquivo.close();
std::cout << "Dados carregados com sucesso!\n";
}

void Menu::salvarDados() {
std::ofstream arquivo("dados.txt");
if (arquivo.is_open()) {
escola.salvarAlunos(arquivo);
escola.salvarProfessores(arquivo);
escola.salvarTurmas(arquivo);
escola.salvarCursos(arquivo);
arquivo.close();
} else {
std::cout << "Erro ao salvar dados.\n";
}
}

void Menu::iniciarSistema() {
escola.carregarDados("dados.txt");
int opcao;

do {
std::cout << "\n--- Menu Principal ---\n";
std::cout << "1. Menu Escola\n";
std::cout << "2. Menu Login\n";
std::cout << "0. Sair\n";
 std::cout << "Escolha uma opcao: ";
std::cin >> opcao;

switch (opcao) {
case 1:
menuEscola();
break;
case 2:
menuLogin();
break;
case 0:
std::cout << "Saindo do sistema.\n";
salvarDados();
break;
default:
std::cout << "Opcao invalida. Tente novamente.\n";
}
} while (opcao != 0);
}

void Menu::menuEscola() {
int opcao;

do {
std::cout << "\n--- Menu Escola ---\n";
std::cout << "1. Criar Professor\n";
std::cout << "2. Criar Aluno\n";
std::cout << "3. Criar Administrador\n";
std::cout << "4. Criar Curso\n";
std::cout << "5. Criar e Adicionar Disciplina ao Curso\n";
std::cout << "6. Criar e Adicionar uma Turma a uma Disciplina\n";
std::cout << "0. Voltar\n";
std::cout << "Escolha uma opcao: ";
std::cin >> opcao;

switch (opcao) {
case 1:
criarProfessor();
break;
case 2:
criarAluno();
break;
case 3:
criarAdministrador();
break;
case 4:
criarCurso();
break;
case 5:
criarDisciplinaCurso();
break;
case 6:
criarTurmaDisciplina();
break;
case 0:
std::cout << "Voltando ao menu principal.\n";
break;
default:
std::cout << "Opcao invalida. Tente novamente.\n";
 }
} while (opcao != 0);
}

void Menu::menuLogin() {
int opcao;

do {
std::cout << "\n--- Menu Login ---\n";
std::cout << "1. Login Professor\n";
std::cout << "2. Login Aluno\n";
std::cout << "3. Login Administrador\n";
std::cout << "0. Voltar\n";
std::cout << "Escolha uma opcao: ";
std::cin >> opcao;

switch (opcao) {
case 1:
loginProfessor();
break;
case 2:
loginAluno();
break;
case 3:
loginAdministrador();
break;
case 0:
std::cout << "Voltando ao menu principal.\n";
break;
default:
std::cout << "Opcao invalida. Tente novamente.\n";
}
} while (opcao != 0);
}

// Fun��es do Menu Escola

void Menu::criarAluno() {
std::string nome, email, senha;
int matricula;

// Exibe a lista de cursos dispon�veis

std::cout << "\n--- Criar Aluno ---\n";
std::cout << "Digite o nome do aluno: ";
std::cin.ignore();
std::getline(std::cin, nome);
std::cout << "Digite o email do aluno: ";
std::cin >> email;
std::cout << "Digite a senha do aluno: ";
std::cin >> senha;

// Exibe a lista de cursos dispon�veis

std::cout << "Selecione o curso:\n";
std::vector<Curso> cursos = escola.getCursos(); // Obt�m a lista de cursos da
escola
for (std::size_t i = 0; i < cursos.size(); ++i) {
std::cout << i + 1 << ". " << cursos[i].getNome() << "\n";
}

std::size_t opcaoCurso;
 std::cout << "Escolha o numero do curso: ";
std::cin >> opcaoCurso;

// Verifica se a op��o � v�lida

if (opcaoCurso < 1 || opcaoCurso > cursos.size()) {
std::cout << "Curso invalido. Tentando novamente...\n";
return;
}

// Obt�m o curso selecionado

Curso cursoSelecionado = cursos[opcaoCurso - 1];

std::cout << "Digite a matricula do aluno: ";

std::cin >> matricula;

// Cria o aluno e adiciona � escola

Aluno* aluno = new Aluno(nome, email, senha, matricula,
cursoSelecionado.getNome());
escola.adicionarAluno(*aluno);

std::cout << "Aluno criado com sucesso!\n";

}

void Menu::criarProfessor() {
std::string nome, email, senha, id;

std::cout << "\n--- Criar Professor ---\n";

std::cout << "Digite o nome do professor: ";
std::cin.ignore();
std::getline(std::cin, nome);
std::cout << "Digite o email do professor: ";
std::cin >> email;
std::cout << "Digite a senha do professor: ";
std::cin >> senha;
std::cout << "Digite o ID do professor: ";
std::cin >> id;

Professor* professor = new Professor(nome, email, senha, id);

escola.adicionarProfessor(*professor);

std::cout << "Professor criado com sucesso!\n";

}

void Menu::criarAdministrador() {
std::string nome, email, senha, codigo;

std::cout << "\n--- Criar Administrador ---\n";

std::cout << "Digite o nome do administrador: ";
std::cin.ignore();
std::getline(std::cin, nome);
std::cout << "Digite o email do administrador: ";
std::cin >> email;
std::cout << "Digite a senha do administrador: ";
std::cin >> senha;
std::cout << "Digite o codigo do administrador: ";
std::cin >> codigo;

Administrador* administrador = new Administrador(nome, email, senha, codigo);

escola.adicionarAdministrador(*administrador);
 std::cout << "Administrador criado com sucesso!\n";
}

void Menu::criarCurso() {
std::string nome, descricao;

std::cout << "\n--- Criar Curso ---\n";

std::cout << "Digite o nome do curso: ";
std::cin.ignore();
std::getline(std::cin, nome);
std::cout << "Digite a descricao do curso: ";
std::getline(std::cin, descricao);

Curso* curso = new Curso(nome, descricao);

escola.adicionarCurso(*curso);

std::cout << "Curso criado com sucesso!\n";

}

void Menu::criarDisciplinaCurso() {
std::string nomeCurso, nomeDisciplina;

std::cout << "\n--- Criar Disciplina e Adicionar ao Curso ---\n";

std::cout << "Digite o nome do curso: ";
std::cin.ignore();
std::getline(std::cin, nomeCurso);
std::cout << "Digite o nome da disciplina: ";
std::getline(std::cin, nomeDisciplina);

Curso* curso = escola.encontrarCurso(nomeCurso);

if (curso) {
curso->adicionarDisciplina(nomeDisciplina);
std::cout << "Disciplina adicionada com sucesso!\n";
} else {
std::cout << "Curso nao encontrado.\n";
}
}

void Menu::criarTurmaDisciplina() {
std::string nomeCurso, nomeDisciplina, codigoTurma, idProfessor;

std::cout << "\n--- Criar Turma e Adicionar a Disciplina ---\n";

std::cout << "Digite o nome do Curso: ";
std::cin.ignore();
std::getline(std::cin, nomeCurso);
std::cout << "Digite o nome da Disciplina: ";
std::getline(std::cin, nomeDisciplina);
std::cout << "Digite o codigo da turma: ";
std::getline(std::cin, codigoTurma);
std::cout << "Digite o ID do professor: ";
std::getline(std::cin, idProfessor);

Disciplina* disciplina = escola.encontrarDisciplina(nomeCurso, nomeDisciplina);

Professor* professor = escola.retornarProfessor(idProfessor);

if (disciplina && professor) {

Turma* turma = new Turma(codigoTurma, disciplina->getNome(), professor);
 disciplina->adicionarTurma(turma);
professor->adicionarTurma(turma);

std::cout << "Turma criada com sucesso!\n";

} else {
std::cout << "Erro: Disciplina ou professor nao encontrado.\n";
}
}

void Menu::loginAluno() {
int matricula;
std::string senha;

std::cout << "Digite a matricula do aluno: ";

std::cin >> matricula;
std::cout << "Digite a senha do aluno: ";
std::cin >> senha;

Aluno* aluno = escola.encontrarAluno(matricula, senha);

if (aluno) {
menuAluno(*aluno);
} else {
std::cout << "Aluno nao encontrado ou senha incorreta.\n";
}
}

void Menu::loginProfessor() {
std::string id, senha;

std::cout << "Digite o ID do professor: ";

std::cin >> id;
std::cout << "Digite a senha do professor: ";
std::cin >> senha;

Professor* professor = escola.encontrarProfessor(id, senha);

if (professor) {
menuProfessor(*professor);
} else {
std::cout << "Professor nao encontrado ou senha incorreta.\n";
}
}

void Menu::loginAdministrador() {
std::string codigo, senha;

std::cout << "Digite o codigo do administrador: ";

std::cin >> codigo;
std::cout << "Digite a senha do administrador: ";
std::cin >> senha;

Administrador* administrador = escola.encontrarAdministrador(codigo, senha);

if (administrador) {
menuAdministrador(*administrador);
} else {
std::cout << "Administrador nao encontrado ou senha incorreta.\n";
}
}

void Menu::menuAluno(Aluno& aluno) {

 int opcao;
do {
std::cout << "\nOla " << aluno.getNome() << std::endl;
std::cout << "\n--- Menu Aluno ---\n";
_____
std::cout << "Escolha uma opcao: ";
std::cin >> opcao;
std::string email;
std::string senha;

switch (opcao) {
case 1:
std::cout << "Digite o novo Email: ";
std::cin >> email;
aluno.alterarEmail(email);
break;
case 2:
std::cout << "Digite a nova Senha: ";
std::cin >> senha;
aluno.alterarSenha(senha);
break;
case 3:
aluno.exibirInformacoes();
break;
case 4:
aluno.consultarNotas();
break;
case 5:
aluno.consultarFrequencia();
break;
case 0:
std::cout << "Saindo do menu do aluno.\n";
break;
default:
std::cout << "Op��o invalida. Tente novamente.\n";
}
} while (opcao != 0);
}

void Menu::menuProfessor(Professor& professor) {

int opcao;
do {
std::cout << "\nOla " << professor.getNome() << std::endl;
std::cout << "\n--- Menu Professor ---\n";
std::cout << "1. Alterar email\n";
std::cout << "2. Alterar senha\n";
std::cout << "3. Consultar informacoes\n";
std::cout << "4. Listar turmas\n";
std::cout << "5. Registrar aluno em turma\n";
std::cout << "6. Dar nota para aluno\n";
std::cout << "7. Registrar frequencia de aluno\n";
std::cout << "0. Sair\n";
std::cout << "Escolha uma opcao: ";
std::cin >> opcao;
std::string email;
std::string senha;

switch (opcao) {
case 1:
 std::cout << "Digite o novo Email: ";
std::cin >> email;
professor.alterarEmail(email);
break;
case 2:
std::cout << "Digite a nova Senha: ";
std::cin >> senha;
professor.alterarSenha(senha);
break;
case 3:
professor.exibirInformacoes();
break;
case 4:
// Listar turmas
std::cout << "Listando turmas...\n";
try {
professor.listarTurmas();
} catch (const std::exception& e) {
std::cout << "Erro ao listar turmas: " << e.what() << "\n";
}
break;
case 5:
// Registrar aluno em turma
{
int idAluno;
std::string codigoTurma;
std::cout << "Digite a matricula do aluno: ";
std::cin >> idAluno;

Aluno* aluno = escola.retornarAluno(idAluno);

if (aluno) {
std::cout << "Digite o codigo da Turma: ";
std::cin.ignore();
std::getline(std::cin, codigoTurma);
professor.registrarAlunoNaTurma(*aluno, codigoTurma);
} else {
std::cout << "Aluno nao encontrado.\n";
}
break;
}
case 6:
// Dar nota para aluno
{
int idAluno;
std::string nomeCurso, nomeDisciplina, codigoTurma;
double nota;
std::cout << "Digite o Nome do Curso: ";
std::cin >> nomeCurso;
std::cout << "Digite o Nome da Disciplina: ";
std::cin >> nomeDisciplina;
std::cout << "Digite a Matricula do Aluno: ";
std::cin >> idAluno;

Aluno* aluno = escola.retornarAluno(idAluno);

Disciplina* disciplina = escola.encontrarDisciplina(nomeCurso,
nomeDisciplina);

if (aluno && disciplina) {

std::cout << "Digite o codigo da Turma: ";
 std::cin.ignore();
std::getline(std::cin, codigoTurma);
std::cout << "Digite a nota: ";
std::cin >> nota;
Turma* turma = escola.encontrarTurma(nomeCurso, disciplina-
>getNome(), codigoTurma);
professor.registrarNotaAluno(*aluno, turma, nota);
} else {
if(disciplina) std::cout << "Aluno nao encontrado.\n";
if(aluno) std::cout << "Curso ou Disciplina nao
encontrado.\n";
}
break;
}
case 7:
// Registrar frequ�ncia de aluno
{
int idAluno;
std::string nomeCurso, nomeDisciplina, codigoTurma;
double frequencia;
std::cout << "Digite o Nome do Curso: ";
std::cin >> nomeCurso;
std::cout << "Digite o Nome da Disciplina: ";
std::cin >> nomeDisciplina;
std::cout << "Digite a Matricula do Aluno: ";
std::cin >> idAluno;

Aluno* aluno = escola.retornarAluno(idAluno);

Disciplina* disciplina = escola.encontrarDisciplina(nomeCurso,
nomeDisciplina);

if (aluno && disciplina) {

std::cout << "Digite o Codigo da Turma: ";
std::cin.ignore();
std::getline(std::cin, codigoTurma);
std::cout << "Digite a frequencia (em porcentagem): ";
std::cin >> frequencia;
Turma* turma = escola.encontrarTurma(nomeCurso, disciplina-
>getNome(), codigoTurma);
professor.registrarFrequenciaAluno(*aluno, turma,
frequencia);
} else {
if(disciplina) std::cout << "Aluno nao encontrado.\n";
if(aluno) std::cout << "Curso ou Disciplina nao
encontrado.\n";
}
break;
}
case 0:
std::cout << "Saindo do menu do professor.\n";
break;
default:
std::cout << "Opcao invalida. Tente novamente.\n";
}
} while (opcao != 0);
}

void Menu::menuAdministrador(Administrador& administrador) {

int opcao;
 do {
std::cout << "\n--- Menu Administrador ---\n";
std::cout << "1. Gerenciar Cursos\n";
std::cout << "2. Gerenciar Professores\n";
std::cout << "3. Gerenciar Alunos\n";
std::cout << "0. Sair\n";
std::cout << "Escolha uma opcao: ";
std::cin >> opcao;

switch (opcao) {
case 1:
//gerenciarCursos(administrador);
break;
case 2:
//gerenciarProfessores(administrador);
break;
case 3:
//gerenciarAlunos(administrador);
break;
case 0:
std::cout << "Saindo do menu administrador.\n";
break;
default:
std::cout << "Opcao invalida. Tente novamente.\n";
}
} while (opcao != 0);
}