#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MED 2
#define PAC 3
#define CONS 3

// Inicialização das variaveis globais //
int cont;
int gercodmedico=0;
int gercodpaciente=0;
int gercodconsulta=0;

// Inicialização das estruturas //
struct Medico
{
    int cod_medico;
    char nome [100];
    char endereco_med [150];
    float salario;
};

struct Medico medicos[MED];

struct Paciente
{
    int cod_paciente;
    char nome_pac[100];
    char endereco_pac[150];
    int idade;
};

struct Paciente pacientes[PAC];

struct Consulta
{
    int num_prontuario;
    char data_consulta[11];
    char diagnostico[150];
    int cod_paciente;
    int cod_medico;
};

struct Consulta consultas[CONS];

// Inicialização das funções referente a medicos //

// Inicialização da função "adicionarmedico //
void adicionarmedico ()
{

    system ("cls");

    /* Primeiro ele vai verificar se o vetor medicos na posição "cont" tem valor diferente de -1. Se sim, o programa
    pulará essa posição, e continuará a fazer verificação, até encontrar uma posição que tem valor -1. Nisso, significa
    que nenhum médico foi preenchido nessa posição. Será requisitado do usuário os dados que serão requisitados do médico
    Caso o usuário tente preencher com mais médicos que permite o vetor, retornará uma mensagem informando tal erro. Tal
    estrutura se repete em outras interações. */
    for (cont=0; cont < MED; cont++)
    {
        if (medicos[cont].cod_medico != -1)
        {
            continue;
        }

        gercodmedico++;
        medicos[cont].cod_medico=gercodmedico;

        printf ("Preparando para receber informacoes do medico %d\n", cont+1);

        printf ("Insira o nome do medico %d: ", cont+1);
        fflush(stdin);
        gets(medicos[cont].nome);

        printf ("Insira o endereco do medico %d: ", cont+1);
        fflush (stdin);
        gets (medicos[cont].endereco_med);

        printf ("Insira o salario do medico %d: ", cont+1);
        scanf ("%.2f", &medicos[cont].salario);
        fflush(stdin);

        return;
    }

    printf ("Capacidade de medicos cheia! Apague um medico do cadastro!\n");
    system ("pause");
}

// Inicialização da função "apagarmedico" //
void apagarmedico ()
{

    system ("cls");

    int verifmedico, apagaconf=0;

    printf ("Vamos verificar primeiro se o medico possui alguma consulta marcada.\n");

    /* "verifmedico" é uma variavel que servirá como referência. */
    do
    {
    printf ("Por favor, insira o codigo do medico. Lembre que deve ser um numero valido de 1 a %d: ", MED);
        scanf ("%d", &verifmedico);
        verifmedico--;
    }while (verifmedico  < 0 || verifmedico > MED-1);

    /* Verificando se no vetor "medicos", utilizando como referência "verifmedico", possui algum medico registrado.
    Caso o valor seja "-1", não há medico. Outro valor, ele continuará o programa. */
    if (medicos[verifmedico].cod_medico == -1)
    {
        printf ("Posicao vazia! Nao ha medico!\n");
        system ("pause");
        return;
    }

    int achou = 0;

    /* Verificação se o medico possui alguma consulta agendada, segundo a data. */
    for (cont=0; cont < CONS; cont++)
    {
        if (consultas[cont].num_prontuario == -1)
        {
            continue;
        }
        /* Vai verificar se no vetor"consultas", possui alguma incidência que seja igual ao que está registrado em
        "medicos[verifmedico].cod_medico". Se sim, achou recebera valor de 1. Se não, significa que não há consul-
        tas agendadas, e o médico poderá ter seu registro apagado. */
        if (consultas[cont].cod_medico == medicos[verifmedico].cod_medico)
        {
                achou = 1;
                break;
        }
    }

    if(achou){
        printf ("Esse medico tem hora marcada!\n");
    }
    else
    {
            printf ("Esse medico nao tem hora marcada. Gostaria de apagar sua entrada?\n ");
            printf ("Digite 1 e ENTER para CONFIRMAR. Outro numero e ENTER para CANCELAR.\n");
            scanf (" %d", &apagaconf);
            fflush (stdin);

            if (apagaconf == 1)
            {
                medicos[verifmedico].cod_medico = -1;
                printf ("Apagado com sucesso!\n");
            }

            else
            {
                printf ("Medico nao apagado. Ele pode ser cadastrado em consulta futuras.\n.");
            }
    }
    system ("pause");
}
// Fim das funções referentes a medico //

// Inicio das funções referentes a paciente //
void adicionarpaciente ()
{

    system ("cls");

    for (cont=0; cont < CONS; cont++)
    {

    if (pacientes[cont].cod_paciente != -1)
        {
            continue;
        }

        gercodpaciente++;
        pacientes[cont].cod_paciente=gercodpaciente;

        printf ("Preparando para receber informacoes do paciente %d\n", cont+1);

        printf ("Insira o nome do paciente %d: ", cont+1);
        fflush(stdin);
        gets(pacientes[cont].nome_pac);

        printf ("Insira o endereço do paciente %d: ", cont+1);
        fflush (stdin);
        gets (pacientes[cont].endereco_pac);

        printf ("Insira a idade do paciente %d: ", cont+1);
        scanf ("%f", &pacientes[cont].idade);

        return;
    }

    printf ("Capacidade de pacientes cheia! Apague um paciente do cadastro!\n");
    system ("pause");
}

// Fim das funções de pacientes    //

void adicionarconsulta()
{

    system ("cls");

    for (cont=0; cont < CONS; cont++)
    {
    if (consultas[cont].num_prontuario != -1)
        {
            continue;
        }

        gercodconsulta++;
        consultas[cont].num_prontuario=gercodconsulta;

        printf ("Preparando para receber informacoes da consulta %d\n", cont+1);

        printf ("Insira a data da consulta %d, sem as barras: ", cont+1);
        fflush(stdin);
        gets(consultas[cont].data_consulta);

        printf ("Insira o diagnostico %d: ", cont+1);
        fflush (stdin);
        gets (consultas[cont].diagnostico);

        // laço criado para buscar o codigo do paciente para adicionar a consulta //
        do
        {
            int verifcodpaciente;

            printf ("Insira aqui o codigo do paciente a ser atendido.");
            printf ("Nao esqueca que o codigo deve ir de 1 a %d: ", MED);
            scanf ("%d", &consultas[cont].cod_paciente);
        }while (consultas[cont].cod_paciente < 1 && consultas[cont].cod_paciente > PAC);

        // laço criado para buscar o codigo medico para adicionar a consulta //
        do
        {
            printf ("Insira aqui o codigo do medico atendente.");
            printf ("Nao esqueca que o codigo deve ir de 1 a 3: ");
            scanf ("%d", &consultas[cont].cod_medico);
        }while (consultas[cont].cod_paciente < 1 || consultas[cont].cod_paciente > MED);

        return;
    }

    printf ("Capacidade de consultas cheia! Apague uma consulta do cadastro!\n");
    system ("pause");
}

int buscardata()
{

    system ("cls");

    char buscardata[11];

    fflush (stdin);
    printf ("Vamos procurar por data, informando todas as consultas marcadas.\n");
    printf ("Insira uma data, sem as barras: ");
    gets (buscardata);

    for (cont=0; cont < CONS; cont++)
    {
        if (!strcmp (consultas[cont].data_consulta, buscardata))
        {
            printf ("Numero do prontuario: %d\n", consultas[cont].num_prontuario);
            printf ("Codigo do medico: %d\n", consultas[cont].cod_medico);
            printf ("Codigo do paciente: %d\n", consultas[cont].cod_paciente);
            printf ("Diagonostico: ");
            puts(consultas[cont].diagnostico);
            printf ("\n");
        }

        else
        {
            printf ("Nenhuma consulta foi encontrada para a data!\n");
            break;
        }

    }

    system ("pause");
}

/* Essa função serve para assegurar que os códigos de cada um dos vetores possui "valor vazio", os preenchendo
com o valor "-1". "-1" para o nosso código, é o mesmo que um elemento vazio. */
void inicializar_medicos()
{
    for (cont =0; cont < MED; cont++)
    {
        medicos[cont].cod_medico = -1;
    }
}

void inicializar_pacientes()
{
    for (cont =0; cont < PAC; cont++)
    {
        pacientes[cont].cod_paciente = -1;
    }
}

void inicializar_consultas()
{
    for (cont =0; cont < CONS; cont++)
    {
        consultas[cont].num_prontuario = -1;
    }
}

/* Função principal */
int main ()
{

    int opc=0;
    /* Incializando todos os vetores referentes a código com valores vazios (aqui um vetor vazio é
    identificado com o valor "-1") */
    inicializar_medicos();
    inicializar_pacientes();
    inicializar_consultas();

    /* Menu de 6 opções. Cada opção é referente a uma das dunções que está descrita. Caso o usuário queira sair do
    programa, poderá entrar com a opção '6', que fechará o programa. */
    do
    {
    system ("cls||clear");

    printf ("Bem vindo ao sistema de Registro e consultas MED-URBAM 1.1!\n");
    printf ("Digite a opcao que voce deseja executar:\n");
    printf ("1 - Incluir medicos\n");
    printf ("2 - Excluir medicos\n");
    printf ("3 - Incluir pacientes\n");
    printf ("4 - Incluir consultas\n");
    printf ("5 - Pesquisar consultas por data\n");
    printf ("6 - Sair do programa\n");

    scanf ("%d", &opc);

    switch (opc)
    {
        case 1:
            adicionarmedico();
            break;

        case 2:
            apagarmedico();
            break;

        case 3:
            adicionarpaciente();
            break;

        case 4:
            adicionarconsulta();
            break;

        case 5:
            buscardata();
            break;

        default:
            printf ("Escolha uma das opcoes validas.");
    }

    }while (opc<6);

    system ("cls");
    printf ("Ate a proxima vez! ;)\n");

    system ("pause");
    return 0;
}