#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    int matricula;
    char nombre[30];
    char genero; //m, f, o
} stAlumno;

int cargarArreglo(stAlumno alumnos[100], int dim);
void mostrarAlumno(stAlumno alumno);
void mostrarArreglo(stAlumno alumnos[100],int validos);
int mostrarAlumnoXmatricula(stAlumno alumnos[100],int validos,int matricula);
void ordenacionXseleccion(stAlumno alumnos[100],int validos);
int buscaPosMenorAlumno(stAlumno alumnos[100], int posInicial, int validos);
int insertarAlumnoArregloOrdenado(stAlumno alumnos[100],int validos,stAlumno nuevoAlumno);
void ordenacionXinsercion(stAlumno alumnos[100],int validos);
int cantidadAlumnosXgenero(stAlumno alumnos[100],int validos,char genero);
void mostrarAlumnoXgenero(stAlumno alumnos[100],int validos,char genero);
stAlumno cargarAlumno();


int main()
{
    stAlumno alumnos[100];
    int alumnosCargados = cargarArreglo(alumnos,100);
    int encontrado = 0;
    char genero = 'm';
    stAlumno nuevoAlumno;
    int opcion = 0;
    int matricula = 0;
    do
    {
        printf("1-Mostrar arreglo\n");
        printf("2-Mostrar alumno con matricula)\n");
        printf("3-Ordenar x Seleccion)\n");
        printf("4-Mostrar alumnos segun genero\n");
        printf("5-Insertar nuevo alumno\n");
        printf("6-Ordenar x Insercion\n");
        printf("7-Cantidad de alumnos con genero\n");
        printf("8-Salir\n");
        scanf("%d", &opcion);
        system("cls");

        // ------ LLAMADO DE FUNCIONES -----------
        switch(opcion)
        {
        case 1:
            mostrarArreglo(alumnos, alumnosCargados);
            break;
        case 2:
            printf("Ingrese la matricula: \n");
            fflush(stdin);
            scanf("%d", &matricula);
            encontrado =mostrarAlumnoXmatricula(alumnos, alumnosCargados,matricula);
            if (encontrado == 0)
                printf("no encontrado!\n");
            break;
        case 3:
            ordenacionXseleccion(alumnos, alumnosCargados);
            mostrarArreglo(alumnos, alumnosCargados);
            break;
        case 4:
            printf("Ingrese el genero: ");
            fflush(stdin);
            scanf("%c", &genero);
            mostrarAlumnoXgenero(alumnos, alumnosCargados, genero);
            break;
        case 5:
            nuevoAlumno = cargarAlumno();
            alumnosCargados = insertarAlumnoArregloOrdenado(alumnos, alumnosCargados,nuevoAlumno);
            break;
        case 6:
            ordenacionXinsercion(alumnos, alumnosCargados);
            mostrarArreglo(alumnos, alumnosCargados);
            break;
        case 7:
            printf("Ingrese el genero: ");
            fflush(stdin);
            scanf("%c", &genero);
            printf("Alumnos encontrados: %d\n",cantidadAlumnosXgenero(alumnos, alumnosCargados, genero));
            break;
        default:
            printf("Opcion invalida");
            break;
        }

    }
    while (opcion != 8);

    return 0;
}

stAlumno cargarAlumno()
{
    stAlumno aux;
    printf("ingrese matricula\n");
    fflush(stdin);
    scanf("%d",&aux.matricula);
    printf("ingrese genero\n");
    fflush(stdin);
    scanf("%c",&aux.genero);
    printf("ingrese nombre\n");
    fflush(stdin);
    scanf("%s",&aux.nombre);
    return aux;
}

//Hacer una función que cargue un arreglo de alumnos, hasta que el usuario lo decida.
int cargarArreglo(stAlumno alumnos[100], int dim)
{
    char mander = 's';
    int indice = 0;
    stAlumno alumnoAux;
    while ((mander == 's')&&(indice<dim))
    {
        alumnoAux = cargarAlumno();

        alumnos[indice] = alumnoAux;

        printf("desea seguir?\n");
        fflush(stdin);
        scanf("%c",&mander);

        indice++;
    }
    return indice;
}

//Hacer una función que muestre un arreglo de alumnos por pantalla. Modularizar.
void mostrarArreglo(stAlumno alumnos[100],int validos)
{
    int indice = 0;
    for (indice =0; indice<validos; indice++)
    {
        stAlumno alumAux = alumnos[indice];
        printf("mostrando alumno %d -> ",indice+1);
        mostrarAlumno(alumAux);
        printf("\n");
    }
}

void mostrarAlumno(stAlumno alumno)
{
    printf("el nombre es ... %s\n",alumno.nombre);
    printf("el genero es ... %c\n",alumno.genero);
    printf("el matricula es ... %d\n",alumno.matricula);
}

//Hacer una función que muestre por pantalla los datos de un alumno, conociendo su matrícula. Modularizar.

int mostrarAlumnoXmatricula(stAlumno alumnos[100],int validos,int matricula)
{
    int encontrado = 0;
    int indice = 0;
    while ((encontrado==0)&&(indice<validos))
    {
        stAlumno alumAux = alumnos[indice];
        if (alumAux.matricula == matricula)
        {
            mostrarAlumno(alumAux);
            encontrado = 1;
        }
        indice++;
    }
    return encontrado;
}

//Hacer una función que ordene el arreglo de alumnos por medio del método de selección. El criterio de ordenación es el número de matrícula.
void ordenacionXseleccion(stAlumno alumnos[100],int validos)
{
    int indice = 0;
    int posMenor = 0;
    stAlumno alumnoMenor;

    while (indice<validos)
    {
        posMenor = buscaPosMenorAlumno(alumnos,indice,validos);
        alumnoMenor = alumnos[posMenor];
        alumnos[posMenor] = alumnos[indice];
        alumnos[indice] = alumnoMenor;
        indice++;
    }
}

int buscaPosMenorAlumno(stAlumno alumnos[100], int posInicial, int validos)
{
    int posMenor = posInicial;
    int menorMatricula = alumnos[posMenor].matricula;
    int indice = posInicial + 1;

    while(indice < validos)
    {
        if (menorMatricula > alumnos[indice].matricula)
        {
            menorMatricula = alumnos[indice].matricula;
            posMenor = indice;
        }
        indice++;
    }
    return posMenor;
}

//Hacer una función que muestre por pantalla los datos de los estudiantes de un género determinado (se envía por parámetro). Modularizar.
void mostrarAlumnoXgenero(stAlumno alumnos[100],int validos,char genero)
{
    for (int indice = 0; indice<validos; indice++)
    {
        if (genero == alumnos[indice].genero)
        {
            mostrarAlumno(alumnos[indice]);
        }
    }
}

//Hacer una función que inserte en un arreglo ordenado por matrícula un nuevo dato, conservando el orden.
int insertarAlumnoArregloOrdenado(stAlumno alumnos[100],int validos,stAlumno nuevoAlumno)
{
    int nuevosValidos = validos + 1;
    int ultimo = validos - 1;

    while ((ultimo>=0)&&(alumnos[ultimo].matricula > nuevoAlumno.matricula))
    {
        alumnos[ultimo+1] = alumnos[ultimo];
        ultimo--;
    }

    alumnos[ultimo+1] = nuevoAlumno;

    return nuevosValidos;
}

void insertarAlumnoArregloOrdenadoxNombre(stAlumno alumnos[100],int ultimo,stAlumno nuevoAlumno)
{
    int indice = ultimo;

     while ( (indice >= 0) && (strcmp(alumnos[indice].nombre,nuevoAlumno.nombre) > 0))
    {
        alumnos[indice+1] = alumnos[indice];
        indice--;
    }
    alumnos[indice+1] = nuevoAlumno;
}

//Hacer una función que ordene el arreglo de alumnos por medio del método de inserción. El criterio de ordenación es el nombre
void ordenacionXinsercion(stAlumno alumnos[100],int validos)
{
    int indice = 0;
    while (indice < validos)
    {
        insertarAlumnoArregloOrdenadoxNombre(alumnos,indice,alumnos[indice+1]);
        indice++;
    }
}

//Hacer una función que cuente y retorne la cantidad de estudiantes de un género determinado (se envía por parámetro) que tiene un arreglo de alumnos.
int cantidadAlumnosXgenero(stAlumno alumnos[100],int validos,char genero)
{
    int contador=0;
    for (int indice = 0; indice<validos; indice++)
    {
        if (genero == alumnos[indice].genero)
        {
            contador++;
        }
    }
    return contador;
}