#include <stdio.h>
#include <stdlib.h>
#include "pila.h"

int cargarArreglo(int arreglo[]);
void mostrarArreglo(int arreglo[],int validos);
int sumaArreglo(int arreglo[],int validos);
void pasarPila(int arreglo[],int validos,Pila * p_pila);
//Pila pasarPila(int arreglo[],int validos,Pila pila);
int cargarArregloReales(float arreglo[]);
void mostrarArregloReales(float arreglo[],int validos);
float sumaArregloReales(float arreglo[],int validos);
int determinaExistencia(char arreglo[],int validos, char caracterBuscado);
int insertarEnOrden(char arreglo[],int validos, char caracterNuevo);
char buscarMayor(char arreglo[],int validos);
int buscarPosMayor(char arreglo[],int validos);
int determinaCapicua(char arreglo[],int validos);
void invertirArreglo(char arreglo[],int validos);

int main()
{
    int arreglo[100] = {0};
    float arregloReales[100] = {0};
    char palabra[100] = "gonzalo";
   // int validos = cargarArreglo(arreglo);
    system("cls");
   // mostrarArreglo(arreglo,validos);
   // int suma  = sumaArreglo(arreglo,validos);
   // printf("la suma del arreglo -> %d",suma);
    Pila pilin;
    inicpila(&pilin);
    //pasarPila(arreglo,validos,&pilin);
    //mostrar(&pilin);

  //  int validosReales = cargarArregloReales(arregloReales);
  //  mostrarArregloReales(arregloReales,validosReales);
  //  float sumaReales = sumaArregloReales(arregloReales,validosReales);
  //  printf("la suma del arreglo reales -> %f",sumaReales);

    //int buscado = determinaExistencia(palabra,10,'p');
    //if (buscado == 1) printf("esta!\n"); else printf("no esta\n");
   // int validosC = insertarEnOrden(palabra,5,'d');
   // printf("nuevos validosC -> %d\n",validosC);
   // printf("%s\n",palabra);

   // char mayor = buscarMayor(palabra,validosC);
  //  printf("el mayor es --> %c\n",mayor);

  //  int posMayor = buscarPosMayor(palabra,validosC);
  //  printf("el mayor es --> %c\n",palabra[posMayor]);

    char capicua[] = "abba";
    printf("es capicua? -> %d\n",determinaCapicua(capicua,4));

    invertirArreglo(palabra,7);
    printf("la palabra nueva es %s\n",palabra);

    return 0;
}

/*
Hacer una función que reciba como parámetro un arreglo de números enteros
y permita que el usuario ingrese valores al mismo por teclado.
La función debe retornar la cantidad de elementos cargados en el arreglo.
*/
int cargarArreglo(int arreglo[])
{
    int validos = 0;
    char mander = 's';
    while ((mander == 's')&&(validos<100))
    {
        printf("ingrese un numero entero en la posicion %d\n",validos+1);
        fflush(stdin);
        scanf("%d",&arreglo[validos]);

        // printf("arreglo %d\n",arreglo[validos]); control

        validos++;//validos = validos + 1
        printf("Desea seguir? s/n \n");
        fflush(stdin);
        scanf("%c",&mander);
    }
    return validos;
}


/*
Hacer una función que reciba como parámetro un arreglo
y la cantidad de elementos (válidos) cargados en él y los muestre por pantalla.
*/
void mostrarArreglo(int arreglo[],int validos)
{
    int indice = 0;
    for (indice = 0; indice<validos; indice++)
    {
        printf("arreglo pos -> %d = %d\n",indice+1,arreglo[indice]);
    }
}

/*
Hacer una función que reciba como parámetro un arreglo
y la cantidad de elementos (válidos) cargados en él y calcule la suma de sus elementos.
*/

int sumaArreglo(int arreglo[],int validos)
{
    int suma = 0;
    int indice = 0;
    for (indice = 0; indice<validos; indice++)
    {
        suma = suma + arreglo[indice];
        //suma += arreglo[indice];
    }
    return suma;
}

/*
Hacer una función que reciba como parámetro un arreglo,
la cantidad de elementos (válidos) cargados en él y una Pila.
La función debe copiar los elementos del arreglo en la pila.
*/
void pasarPila(int arreglo[],int validos,Pila * p_pila)
{
    int indice = 0;
    for (indice = 0; indice<validos; indice++)
    {
        apilar(p_pila,arreglo[indice]);
    }
}

/*
Realizar una función que sume los elementos de un arreglo números reales de dimensión 100.
(para poder hacer esta función, hay que cargar un arreglo de reales,
 se recomienda hacer una función para cargar y otra para mostrar este tipo de arreglos)
 */

 int cargarArregloReales(float arreglo[])
{
    int validos = 0;
    char mander = 's';
    while ((mander == 's')&&(validos<100))
    {
        printf("ingrese un numero real en la posicion %d\n",validos+1);
        fflush(stdin);
        scanf("%f",&arreglo[validos]);

        // printf("arreglo %d\n",arreglo[validos]); control

        validos++;//validos = validos + 1
        printf("Desea seguir? s/n \n");
        fflush(stdin);
        scanf("%c",&mander);
    }
    return validos;
}


void mostrarArregloReales(float arreglo[],int validos)
{
    int indice = 0;
    for (indice = 0; indice<validos; indice++)
    {
        printf("arreglo pos -> %d = %f\n",indice+1,arreglo[indice]);
    }
}



float sumaArregloReales(float arreglo[],int validos)
{
    float sumaReales = 0;
    int indice = 0;
    for (indice = 0; indice<validos; indice++)
    {
        sumaReales = sumaReales + arreglo[indice];
        //suma += arreglo[indice];
    }
    return sumaReales;
}
/*
Realizar una función que indique si un elemento dado se encuentra en un arreglo de caracteres.
*/
int determinaExistencia(char arreglo[],int validos, char caracterBuscado)
{
    int encontrado = 0;
    int indice = 0;

    while ((indice<validos)&&(encontrado==0))
    {
        if (arreglo[indice]==caracterBuscado)
        {
            encontrado = 1;
        }
        /*
        else
        {
            encontrado = 0;
        }
        */
        validos++;
    }

    return encontrado;
}

/*
Realizar una función que inserte un carácter en un arreglo ordenado alfabéticamente,
conservando el orden.
*/
int insertarEnOrden(char arreglo[],int validos, char caracterNuevo)
{
   int indice = validos - 1;
   while ((indice >=0) && (caracterNuevo < arreglo[indice]))
   {
       arreglo[indice+1] = arreglo[indice];
       indice--;
   }
   arreglo[indice+1] = caracterNuevo;
   return validos+1;
}

/*
Realizar una función que obtenga el máximo carácter de un arreglo dado.
*/
char buscarMayor(char arreglo[],int validos)
{
    char mayor = arreglo[0];
    int indice = 0;
    for (indice = 0;indice<validos;indice++)
    {
        if (arreglo[indice]>mayor)
        {
            mayor = arreglo[indice];
        }
    }
    return mayor;
}

int buscarPosMayor(char arreglo[],int validos)
{
    char mayor = arreglo[0];
    int posMayor = 0;
    int indice = posMayor+1;
    for (indice = 1;indice<validos;indice++)
    {
         if (arreglo[indice]>mayor)
        {
            mayor = arreglo[indice];
            posMayor = indice;
        }
    }
    return posMayor;
}

int determinaCapicua(char arreglo[],int validos)
{
    int indice = 0;
    int ultimaPos = validos -1;
    int capicua = 1;
    while ((indice<validos)&&(ultimaPos>=0)&&(capicua==1))
    {
        if (arreglo[indice] == arreglo[ultimaPos])
        {
             indice++;
            ultimaPos--;
        }
        else
        {
            capicua = 0;
        }

    }
    return capicua;
}

void invertirArreglo(char arreglo[],int validos)
{
    int indice = 0;
    char aux;
    int ultimaPos = validos - 1;
    while (indice < ultimaPos)
    {
        aux = arreglo[indice];
        arreglo[indice] = arreglo[ultimaPos];
        arreglo[ultimaPos] = aux;
        indice++;
        ultimaPos--;
    }
}