//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX//

// Lemario.cpp //
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX//
#include <iostream>
#include <list>
#include <vector>
#include <fstream>

using namespace std;

//=====================================================================================//
// Estructuras //
//=====================================================================================//
//-------------------------------------------------------------------------------------//
// Terminaciones //
//-------------------------------------------------------------------------------------//
struct term
{
string s; // tipo de terminacion
int rep; // repeticiones

bool operator< (term &T) { return rep < T.rep; }

bool operator< (const term &T) const { return rep < T.rep; }
bool operator> (term &T) { return rep > T.rep; }
bool operator> (const term &T) const { return rep > T.rep; }

bool operator<= (term &T) { return rep <= T.rep; }

bool operator<= (const term &T) const { return rep <= T.rep; }
bool operator>= (term &T) { return rep >= T.rep; }
bool operator>= (const term &T) const { return rep >= T.rep; }

bool operator== (term &T) { return s == T.s; }

bool operator!= (const term &T) const { return s != T.s; }
};

//=====================================================================================//
// Cabeceras //
//=====================================================================================//
/// @brief crea una lista sin ordenar con las terminaciones de las palabras
/// @param archivo nombre del archivo
/// @param longitud de la terminación
/// @return devuelve la lista de terminaciones
list<string> sacar_lista(string archivo, int longitud);

//-------------------------------------------------------------------------------------//
/// @brief cuenta cuantas terminaciones tienen las palabras del lemario
/// @param L una lista de parejas string, repeticiones
/// @param lem lemario
/// @param longitud, el n de caracteres que se va a leer como terminación
list<term> contar (list<string> & L);

//-------------------------------------------------------------------------------------//
/// @brief mira si existe antes esa terminación
/// @param L una lista de parejas string, repeticiones
/// @param s string a buscar
bool existe(list<term> & L, string s);

//-------------------------------------------------------------------------------------//
/// @brief crea una lista sin ordenar con las terminaciones de las palabras
/// @param archivo nombre del archivo de salida
/// @param lista de términos (se ordenará dentro del archivo)
void guardar(string archivo, list<term> & L);

//=====================================================================================//
// Main //
//=====================================================================================//
int main()
{
list<string> Ls;
 list<term> Lt;

string s = "";

for (int i=1 ; i<11 ; ++i)

{
Ls = sacar_lista("Lemario_sa_axo.txt", i);
Lt = contar (Ls);

s = "TermAO";
s += (char)((i/10) +48);
s += (char)((i%10) + 48);
s += ".txt";

guardar(s, Lt);
}

for (int i=1 ; i<16 ; ++i)

{
Ls = sacar_lista("Lemario_sin_acentos.txt", i);
Lt = contar (Ls);

s = "Term";
s += (char)((i/10) +48);
s += (char)((i%10) + 48);
s += ".txt";

guardar(s, Lt);
}

return 0;
}

//=====================================================================================//
// Funciones //
//=====================================================================================//
//-------------------------------------------------------------------------------------//
// Sacar lista //
//-------------------------------------------------------------------------------------//
list<string> sacar_lista(string archivo, int longitud)
{
list<string> Ls;
char* c = new char[256];
string s;

ifstream fi(archivo.c_str());

if (!fi)
{
cout << "El archivo " << system("pwd") << archivo;
cout << "No se ha podido abrir";
return Ls;
}

fi.getline(c, 256);

while (!fi.eof())
{
s = c;
if ((signed)s.length() >= longitud)
{
s = s.erase(0, s.length()-longitud);
Ls.push_back(s);
}
fi.getline(c, 256);
}

fi.close();
 Ls.sort();

return Ls;
}

//-------------------------------------------------------------------------------------//
// Contar //
//-------------------------------------------------------------------------------------//
list<term> contar (list<string> & Ls)
{
list<term> Lt;
term te;

te.rep = 1;
te.s = Ls.front();

for (list<string>::iterator it = (Ls.begin())++ ; it !=Ls.end(); ++it)

{
if( (*it) == te.s)
{
te.rep++;
}
else
{
if (te.rep >= 100) // Si se repite más de 100 veces
Lt.push_back(te);

te.rep = 1;
te.s = (*it);
}
}

Lt.sort();

return Lt;
}

//-------------------------------------------------------------------------------------//
// Existe //
//-------------------------------------------------------------------------------------//
bool existe(list<term> & L, string s)
{
for (list<term>::iterator it = L.begin() ; it !=L.end(); ++it)
if( (*it).s == s)
return true;

return false;
}

//-------------------------------------------------------------------------------------//
// Guardar //
//-------------------------------------------------------------------------------------//
void guardar(string archivo, list<term> & L)
{
L.sort();

ofstream fo(archivo.c_str());

for (list<term>::reverse_iterator it = L.rbegin() ; it !=L.rend(); ++it)

fo << (*it).s << "\t" << (*it).rep << "\n";

fo. close();
}