//
//  Empleado.h
//  ELE
//
//  Created by Edson Guízar on 21/04/16.
//  Copyright (c) 2016 Edson Jardiel Guízar Cruz. All rights reserved.
//

#include<iostream>
#define N1 1750
#define N2 1100
#define N3 750
#define N4 390
#define N5 240


using namespace std;

/* Prototipo de la plantilla de la clase Lista. AsÌ, en la clase NodoLista
 se podr· hacer referencia a ella. */

template <class T>
class Lista;

template <class T>
class NodoLista
{
private:
    NodoLista<T> *Liga;
    T Info;
public:
    NodoLista();
    T RegresaInfo();
    NodoLista<T>*RegresaLiga();
    void setInfo(T info);
    friend class Lista<T>;
    friend class NominaC;
};

/* DeclaraciÛn del mÈtodo constructor por defecto. Inicializa con el valor NULL
 al apuntador al siguiente nodo. */
template <class T>
NodoLista<T>::NodoLista()
{
    Liga=NULL;
}

/* MÈtodo que permite, a usuarios ajenos a la clase, conocer el valor del
 atributo Info. */
template <class T>
T NodoLista<T>::RegresaInfo()
{
    return Info;
}

template <class T>
NodoLista<T>* NodoLista<T>::RegresaLiga(){
    
    return Liga;
}

template <class T>
void NodoLista<T>::setInfo(T info){
    Info=info;
}

/* DefiniciÛn de la clase Lista */
template <class T>
class Lista
{
private:
    NodoLista<T> *Primero;
public:
    Lista();
    NodoLista<T> *RegresaPrimero();
    void CreaInicio();
    void CreaFinal();
    void ImprimeIterativo();
    void ImprimeRecursivo(NodoLista<T> *);
    void ImprimeUnNodo(NodoLista<T> *);
    void InsertaInicio(T);
    void InsertaFinal(T);
    void InsertaOrdenCrec(T);
    int InsertaAntes(T, T);
    int InsertaDespues(T, T);
    int EliminaPrimero();
    int EliminaUltimo();
    int EliminaUnNodo(T);
    int EliminaAnterior(T);
    int EliminaDespues(T);
    int Conta(int,NodoLista<T>*);
    NodoLista<T> *BuscaDesordenada(T);
    NodoLista<T> *BuscaOrdenada(T);
    NodoLista<T> *BuscaRecursivo(T, NodoLista<T> *);
    friend class NominaC;
};

/* DeclaraciÛn del mÈtodo constructor. Inicializa el apuntador al primer nodo
 de la lista con el valor NULL: indica la lista vacÌa. */
template <class T>
Lista<T>::Lista()
{
    Primero=NULL;
}

/* MÈtodo que regresa la direcciÛn de primer nodo de la lista. */
template <class T>
NodoLista<T> *Lista<T>::RegresaPrimero()
{
    return Primero;
}

template <class T>

int Lista<T>::Conta(int d,NodoLista<T> *Apunt){
    if (Apunt!=NULL)
    {
        
        Conta(d,Apunt->Liga);
        d++;
    }
    
    return d;
}

/* MÈtodo que crea una lista agregando el nuevo nodo al inicio de la misma. */
template <class T>
void Lista<T>::CreaInicio()
{
    NodoLista<T> *P;
    T Dato;
    char Resp;
    Primero=new NodoLista<T>();
    cout << "Introduce la informacion a almacenar: \n";
    cin >> Dato;
    Primero->Info=Dato;
    cout << "\nDeseas introducir otro elemento (S/N)? ";
    cin >> Resp;
    while (Resp == 'S' || Resp =='s')
    {
        cout << "Introduce la informacion: \n";
        cin >> Dato;
        P=new NodoLista<T>();
        P->Info=Dato;
        P->Liga=Primero;
        Primero=P;
        cout << "\nDeseas agregar otro elemento (S/N)? ";
        cin >> Resp;
    }
}

/* MÈtodo que crea una lista agregando el nuevo nodo al final de la misma. */
template <class T>
void Lista<T>::CreaFinal()
{
    NodoLista<T> *P, *Ultimo;
    T Dato;
    char Resp;
    Primero=new NodoLista<T>();
    cin >> Dato;
    Primero->Info=Dato;
    /* Se mantiene el apuntador al ˙ltimo nodo agregado a la lista para evitar
     tener que recorrerla con cada nuevo nodo. */
    Ultimo=Primero;
    cout << "\nDeseas introducir otro elemento (S/N)? ";
    cin >> Resp;
    while (Resp == 'S' || Resp =='s')
    {
        cin >> Dato;
        P=new NodoLista<T>();
        P->Info=Dato;
        Ultimo->Liga=P;
        Ultimo=P;
        cout << "\nDeseas agregar otro elemento (S/N)? ";
        cin >> Resp;
    }
}

/* MÈtodo que imprime el contenido de la lista de forma iterativa. */
template <class T>
void Lista<T>::ImprimeIterativo()
{
    NodoLista<T> *P;
    P=Primero;
    while (P)
    {
        cout << '\n'<<P->Info;
        P=P->Liga;
    }
    cout << "\n";
}

/* MÈtodo que imprime el contenido de la lista de forma recursiva. Recibe como
 par·metro el nodo cuya informaciÛn se va a imprimir. */
template <class T>
void Lista<T>::ImprimeRecursivo(NodoLista<T> *P)
{
    if (P)
    {
        cout << P->Info;
        ImprimeRecursivo(P->Liga);
    }
    cout << "\n";
}

/* MÈtodo que imprime la informaciÛn de un nodo dado como dato. */
template <class T>
void Lista<T>::ImprimeUnNodo(NodoLista<T> *P)
{
    if (P)
        cout << '\n'<<P->Info;
}

/* MÈtodo que inserta un nodo al inicio de la lista. El mÈtodo es v·lido tanto
 para listas ya creadas como para listas vacÌas. */
template <class T>
void Lista<T>::InsertaInicio(T Dato)
{
    NodoLista<T> *P;
    P=new NodoLista<T>();
    P->Info=Dato;
    P->Liga=Primero;
    Primero=P;
}

/* MÈtodo que inserta un nodo al final de la lista. El mÈtodo es v·lido tanto
 para listas ya creadas como para listas vacÌas. */
template <class T>
void Lista<T>::InsertaFinal(T Dato)
{
    NodoLista<T> *P, *Ultimo;
    P=new NodoLista<T>();
    P->Info=Dato;
    if (Primero)
    {
        /* Si la lista tiene al menos un elemento, entonces se debe recorrer
         hasta llegar al ˙ltimo nodo. */
        Ultimo=Primero;
        while (Ultimo->Liga)
            Ultimo=Ultimo->Liga;
        /* El ˙ltimo nodo de la lista apunta al nuevo nodo, cuya direcciÛn
         est· en P. */
        Ultimo->Liga=P;
    }
    else
    /* Si la lista no tiene elementos, entonces el nuevo elemento ser· el
     primero de la misma. */
        Primero=P;
}

/* MÈtodo que inserta un nodo en orden creciente. Luego de varias inserciones,
 usando este mÈtodo, se habr· generado una lista ordenada de menor a mayor. */
template <class T>
void Lista<T>::InsertaOrdenCrec(T Dato)
{
    NodoLista<T> *P, *Q, *Ant;
    if (!Primero || Primero->Info > Dato)
        InsertaInicio(Dato);
    else
    {
        Q=Primero;
        while (Q && Q->Info < Dato)
        {
            Ant=Q;
            Q=Q->Liga;
        }
        P=new NodoLista<T>();
        P->Info=Dato;
        Ant->Liga=P;
        P->Liga=Q;
    }
}

/* MÈtodo que inserta un nodo antes de un nodo dado como referencia. Recibe como
 par·metros la informaciÛn a insertar y un dato dado como referencia.
 Regresa 1 si se pudo insertar, 0 si no se encontrÛ la referencia y -1 si la
 lista est· vacÌa. */
template <class T>
int Lista<T>::InsertaAntes(T Dato, T Ref)
{
    NodoLista<T> *P, *Ant, *Q;
    int Resp=1;
    if (Primero)
    {
        Q=Primero;
        while ((Q!=NULL) && (Q->Info!=Ref))
        {
            Ant=Q;
            Q=Q->Liga;
        }
        if (Q!=NULL)
        {
            P=new NodoLista<T>();
            P->Info=Dato;
            /* El dato de referencia es el primero de la lista. */
            if (Primero==Q)
            {
                P->Liga=Primero;
                Primero=P;
            }
            else
            {
                Ant->Liga=P;
                P->Liga=Q;
            }
        }
        else
        /* No se encontrÛ el dato como referencia. */
            Resp=0;
    }
    else
    /* La lista est· vacÌa. */
        Resp=-1;
    return Resp;
}

/* MÈtodo que inserta un nodo despuÈs de uno dado como referencia. Recibe como
 par·metros la informaciÛn a insertar y la refeencia. Regresa 1 si se pudo
 insertar, 0 si no se encontrÛ el dato dado y -1 si la lista est· vacÌa. */
template <class T>
int Lista<T>::InsertaDespues(T Dato, T Ref)
{
    NodoLista<T> *Q, *P;
    int Resp=1;
    if (Primero)
    {
        Q=Primero;
        while((Q!=NULL) && (Q->Info!=Ref))
            Q=Q->Liga;
        if (Q!=NULL)
        {
            P=new NodoLista<T>();
            P->Info=Dato;
            P->Liga=Q->Liga;
            Q->Liga=P;
        }
        /* No se encontrÛ la referencia. */
        Resp=0;
    }
    else
    /* La lista est· vacÌa. */
        Resp=-1;
    return Resp;
}

/* MÈtodo que elimina el primer elemento de la lista. El mÈtodo redefine el
 apuntador al inicio de la lista y libera el espacio de memoria del nodo
 eliminado. Regresa 1 si se pudo llevar a cabo la operaciÛn y 0 en caso
 contrario. */
template <class T>
int Lista<T>::EliminaPrimero()
{
    NodoLista<T> *P;
    int Resp=1;
    if (Primero)
    {
        P=Primero;
        Primero=P->Liga;
        delete (P);
    }
    else
    /* La lista est· vacÌa. */
        Resp=0;
    return Resp;
    
}

/* MÈtodo que elimina el ˙ltimo elemento de una lista. Primero lo localiza,
 guardando la direcciÛn del nodo que le precede. Posteriormente redefine la
 liga de Èste con el valor NULL para indicar que ahora Èste es el ˙ltimo y
 libera el espacio de memoria. Regresa 1 si se efectuo la eliminaciÛn y 0
 en caso contrario. */
template <class T>
int Lista<T>::EliminaUltimo()
{
    NodoLista<T> *Ant, *P;
    int Resp=1;
    if (Primero)
    {
        /* Verifica si la lista est· formada por un ˙nico elemento, en tal caso
         redefine el apuntador al inicio con el valor NULL, indicando lista
         vacÌa. */
        if (!Primero->Liga)
        {
            delete (Primero);
            Primero=NULL;
        }
        else
        {
            P=Primero;
            while (P->Liga)
            {
                Ant=P;
                P=P->Liga;
            }
            Ant->Liga=NULL;
            delete (P);
        }
    }
    else
    /* La Lista est· vacÌa. */
        Resp=0;
    return Resp;
}

/* MÈtodo que elimina un nodo que almacena cierta informaciÛn. Recibe como
 par·metro el dato a eliminar y regresa como resultado 1 si lo elimina, 0
 si no lo encuentra y -1 si la lista est· vacÌa. */
template <class T>
int Lista<T>::EliminaUnNodo(T Ref)
{
    NodoLista<T> *P, *Ant;
    int Resp=1;
    if (Primero)
    {
        P=Primero;
        while ((P->Liga)&&(P->Info!=Ref))
        {
            Ant=P;
            P=P->Liga;
        }
        if (P->Info!=Ref)
        /* El elemento no fue encontrado. */
            Resp=0;
        else
        {
            if (Primero==P)
                Primero=P->Liga;
            else
                Ant->Liga=P->Liga;
            delete (P);
        }
    }
    else
        Resp=-1;
    return Resp;
}

/* MÈtodo que elimina el nodo anterior al nodo que almacena un dato dado como
 referencia. Regresa 1 si el nodo fue eliminado, 2 si la referencia es el
 primero, 3 si no fue encontrado y 4 si la lista est· vacÌa. */
template <class T>
int Lista<T>::EliminaAnterior(T Ref)
{
    NodoLista<T> *Q, *Ant, *P;
    int Resp=1;
    if (Primero)
    {
        if (Primero->Info==Ref)
        /* No hay nodo que preceda al proporcionado como referencia. */
            Resp=2;
        else
        {
            Q=Primero;
            Ant=Primero;
            /* Ciclo que permite encontrar la informaciÛn dada como referencia,
             guardando la direcciÛn del nodo que le precede (nodo que se
             eliminar·) y del anterior a Èste para establecer las ligas
             correspondientes. */
            while ((Q->Info!=Ref)&&(Q->Liga))
            {
                P=Ant;
                Ant=Q;
                Q=Q->Liga;
            }
            if (Q->Info!=Ref)
            /* El elemento dado como referencia no est· en la lista. */
                Resp=3;
            else
                if (Primero->Liga==Q)
                {
                    delete (Primero);
                    Primero=Q;
                }
                else
                {
                    P->Liga=Q;
                    delete (Ant);
                }
        }
    }
    else
    /* La lista est· vacÌa. */
        Resp =4;
    return Resp;
}

/* MÈtodo que busca un elemento dado como referencia en una lista desordenada.
 Regresa la direcciÛn del nodo si lo encuentra y NULL en caso contrario. */
template <class T>
NodoLista<T> *Lista<T>::BuscaDesordenada(T Ref)
{
    NodoLista<T> *Q, *Resp=NULL;
    if (Primero)
    {
        Q=Primero;
        while ((Q->Info!=Ref)&&(Q->Liga))
            Q=Q->Liga;
        /* Se verifica si el elemento dado como referencia fue encontrado en
         la lista. */
        if (Q->Info==Ref)
            Resp=Q;
    }
    return Resp;
}

/* MÈtodo que busca un elemento dado como referencia, en una lista ordenada
 de menor a mayor. Regresa la direcciÛn del nodo si lo encuentra y NULL en
 caso contrario. */
template <class T>
NodoLista<T> *Lista<T>::BuscaOrdenada(T Ref)
{
    NodoLista<T> *Q, *Resp=NULL;
    if (Primero)
    {
        Q=Primero;
        while ((Q->Info < Ref)&&(Q->Liga))
            Q=Q->Liga;
        /* Se verifica si el elemento dado como referencia fue encontrado en
         la lista. */
        if (Q->Info==Ref)
            Resp=Q;
    }
    return Resp;
}

/* MÈtodo que busca un dato en la lista. La operaciÛn se realiza recursivamente.
 El mÈtodo recibe como par·metro el elemento a buscar (Dato) y una variable
 (Q) que almacena la direcciÛn de un nodo (la primera vez es la direcciÛn
 del primero). Regresa como resultado la direcciÛn del nodo si lo encuentra
 y NULL en caso contrario. */
template <class T>
NodoLista<T> *Lista<T>::BuscaRecursivo(T Dato, NodoLista<T> *Q)
{
    if (Q)
        if (Q->Info==Dato)
            return Q;
        else
            return BuscaRecursivo(Dato, Q->Liga);
        else
            return NULL;
}


char aux[2];

class Empleado{
    
protected:
    string Nombre="";
    int ID=0;
    int Departamento=0;
    int Nivel=0;
    int Antiguedad=0;
    int TipoContrato=0;
    int DiasTrabajados=0;
    int HorasExtra=0;
    double Salario=0;
    double Bonos=0;
    double Descuentos=0;
    friend class NominaC;
    
public:
    
    Empleado(){ }
    Empleado(string N, int I, int D, int Ni, int A, int TC, double S, int DT, int HE, double B, double De){
        setNombre(N);
        setID(I);
        setDepartamento(D);
        setNivel(Ni);
        setAntiguedad(A);
        setTipoContrato(TC);
        setSalario(S);
        setDiasTrabajados(DT);
        setHorasExtra(HE);
        setBonos(B);
        setDescuentos(De);
    }
    
    string getNombre(){ return Nombre; }
    void setNombre(string Nom){ Nombre=Nom; }
    
    int getID(){ return ID; }
    void setID(int id){ ID=id; }
    
    int getDepartamento(){ return Departamento; }
    void setDepartamento(int Dep){ Departamento=Dep; }
    
    int getNivel(){ return Nivel; }
    void setNivel(int Ni){ Nivel=Ni; }
    
    int getAntiguedad(){ return Antiguedad; }
    void setAntiguedad(int An){ Antiguedad=An; }
    
    int getTipoContrato(){ return TipoContrato; }
    void setTipoContrato(int TiC){ TipoContrato=TiC; }
    
    int getHorasExtra(){ return HorasExtra; }
    void setHorasExtra(int HoE){ HorasExtra=HoE; }
    
    double getSalario(){ return Salario; }
    void setSalario(double Sa){ Salario=Sa; }
    
    int getDiasTrabajados(){ return DiasTrabajados; }
    void setDiasTrabajados(int DiT){ DiasTrabajados=DiT; }
    
    double getBonos(){ return Bonos; }
    void setBonos(double Bon){ Bonos=Bon; }
    
    double getDescuentos(){ return Descuentos; }
    void setDescuentos(double Des){ Descuentos=Des; }
    
    
    void CalculaSalario(){
        
        switch (Departamento) {
            case 1:
                switch (Nivel) {
                    case 1:
                        Salario=N1*1.2;
                        break;
                    case 2:
                        Salario=N2*1.2;
                        break;
                    case 3:
                        Salario=N3*1.2;
                        break;
                    case 4:
                        Salario=N4*1.2;
                        break;
                    case 5:
                        Salario=N5*1.2;
                        break;
                    default:
                        break;
                }
                break;
                
            default:
                break;
        }
        
    }
    
    void setSalario(double Bonos, double Descuentos, int HorasExtra, int DiasTrab){
        Salario=(((Salario/12)*DiasTrab)+(HorasExtra*30)+Bonos-Descuentos);
    }
    
    
    /* MÈtodo que permite comparar dos objetos de tipo Producto para determinar si
     son iguales. Regresa 1 si los productos son iguales (tienen la misma clave)
     y 0 en caso contrario. Se usa sobrecarga del operador ==. */
    int operator == (Empleado E)
    {
        int Resp=0;
        if (ID==E.ID)
            Resp=1;
        return Resp;
    }
    
    /* MÈtodo que permite comparar dos objetos de tipo Producto para determinar si
     son distintos. Regresa 1 si los productos son distintos (tienen diferente
     clave) y 0 en caso contrario. Se usa sobrecarga del operador !=. */
    int operator != (Empleado E)
    {
        int Resp=0;
        if (ID!=E.ID)
            Resp=1;
        return Resp;
    }
    
    
    /* MÈtodo que permite comparar dos objetos de tipo Producto para determinar si
     el asociado al operador es mayor que el dado como par·metro. Regresa 1
     cuando es mayor (su clave es mayor que la clave del dado como par·metro)
     y 0 en caso contrario. Se usa sobrecarga del operador >, */
    int operator > (Empleado E)
    {
        int Resp=0;
        if (ID > E.ID)
            Resp=1;
        return Resp;
    }
    
    /* MÈtodo que permite comparar dos objetos de tipo Producto para determinar si
     el asociado al operador es menor que el dado como par·metro. Regres 1 cuando
     es menor (su clave es menor que la clave del dado como par·metro) y 0 en
     caso contrario. Se usa sobrecarga del operador <. */
    int operator < (Empleado E)
    {
        int Resp=0;
        if (ID < E.ID)
            Resp=1;
        return Resp;
    }
    
    friend istream &operator>>(istream &, Empleado &);
    friend ostream &operator<<(ostream &, Empleado &);
    
};

ostream &operator<<(ostream &Imprime, Empleado &E) {
    
    Imprime<<E.getID()<<setw(30)<<E.getNombre()<<setw(18)<<E.getDepartamento()<<setw(6)<<E.getNivel()<<
    setw(7)<<E.getAntiguedad()<<setw(14)<<E.getTipoContrato()<<setw(10)<<E.getSalario()<<setw(12)<<E.getDiasTrabajados()<<setw(7)<<E.getHorasExtra()<<setw(7)<<E.getBonos()<<setw(7)<<E.getDescuentos();
    
    return Imprime;
}

istream &operator>>(istream &Escribe, Empleado &E){
    int datoint;
    char aux[2];
    string datostr;
    cout<<endl;
    cout<<"ID: ";
    cin>>datoint;
    E.setID(datoint);
    cin.getline(aux, 2);
    cout<<"Nombre: ";
    getline(cin, datostr);
    E.setNombre(datostr);
    cout<<"Departamento: ";
    cin>>datoint;
    E.setDepartamento(datoint);
    cout<<"Nivel: ";
    cin>>datoint;
    E.setNivel(datoint);
    cout<<"Antigüedad: ";
    cin>>datoint;
    E.setAntiguedad(datoint);
    cout<<"Tipo de contrato: ";
    cin>>datoint;
    E.setTipoContrato(datoint);
    cout<<endl;
    E.CalculaSalario();
    
    return Escribe;
}

#include <iostream>
#include <string>
#include <iomanip>
#include "Empleado.h"
#include "stdlib.h"
#include <fstream>
#define N1 1750
#define N2 1100
#define N3 750
#define N4 390
#define N5 240

using namespace std;

class NominaC{
    Lista<Empleado> N;
    NodoLista<Empleado> Auxi,*Auxi2;
    int NumeroEmpleados=0;
public:
    
    void CargarArchivo(){
        int a;
        string Nombre;
        int ID;
        int Departamento;
        int Nivel;
        int Antiguedad;
        int TipoContrato;
        int DiasTrabajados;
        int HorasExtra;
        double Salario;
        double Bonos;
        double Descuentos;
        NodoLista<Empleado> *Auxiliar=N.RegresaPrimero();
        Empleado A;
        ifstream cargar;
        cargar.open("numero.txt",ios::in);
        cargar>>NumeroEmpleados;
        cargar.close();
        cargar.open("datos.txt",ios::in);
            while(Auxiliar){
            cargar>>ID>>Nombre>>Departamento>>Nivel>>Antiguedad>>TipoContrato>>DiasTrabajados>>HorasExtra>>Salario>>Bonos>>Descuentos;
                A.setID(ID);
                A.setNombre(Nombre);
                A.setDepartamento(Departamento);
                A.setNivel(Nivel);
                A.setAntiguedad(Antiguedad);
                A.setTipoContrato(TipoContrato);
                A.setDiasTrabajados(DiasTrabajados);
                A.setHorasExtra(HorasExtra);
                A.setSalario(Salario);
                A.setBonos(Bonos);
                A.setDescuentos(Descuentos);
                N.InsertaOrdenCrec(A);
                Auxiliar->setInfo(A);
                Auxiliar=Auxiliar->RegresaLiga();
                
            }
            
        
        
        cargar.close();
    }
    
    void guardarElemento(){
        NodoLista<Empleado> *Auxiliar;
        Empleado A;
        ofstream guardar;
        guardar.open("numero.txt",ios::out);
        guardar<<NumeroEmpleados;
        guardar.close();
        guardar.open("datos.txt",ios::out);
            while(Auxiliar){
                A=Auxiliar->RegresaInfo();
            guardar<<A.getID()<<"     "<<A.getNombre()<<"     "<<A.getDepartamento()<<"     "<<A.getNivel()<<"     "<<A.getAntiguedad()<<"     "
                <<A.getTipoContrato()<<"     "<<A.getDiasTrabajados()<<"     "<<A.getHorasExtra()<<"     "<<A.getSalario()<<"     "<<A.getBonos()
                <<"     "<<A.getDescuentos()<<endl;
                Auxiliar=Auxiliar->RegresaLiga();
        
        guardar.close();
    }
    }
    
    void AgregarEmpleado(){
        Empleado A;
        cin>>A;
        N.InsertaOrdenCrec(A);
        NumeroEmpleados++;
        guardarElemento();
    }
    
    void EliminarEmpleado(){
        int id,res;
        cout<<"ID del empleado: ";
        cin>>id;
        Empleado X(" ", id, 0, 0, 0, 0, 0, 0,0,0,0);
        res=N.EliminaUnNodo(X);
        switch (res)
        {
            case 1:  cout << "El empleado ha sido eliminado.\n";
                NumeroEmpleados--;
                break;
            case 0:  cout << "El ID no esta registrado.\n";
                break;
            case -1: cout << "No hay empleados registrados.\n";
                break;
        }
    }
    
    void EditarEmpleado(){
        int id,dato;
        cout<<"ID del empleado: ";
        cin>>id;
        Empleado X(" ", id, 0, 0, 0, 0, 0, 0,0,0,0),A;
        if(N.BuscaOrdenada(X)){
            Auxi=*N.BuscaOrdenada(X);
            A=Auxi.RegresaInfo();
            N.EliminaUnNodo(X);
            int cambio;
            cout<<"¿Qué dato deseas editar?\n(1) Departamento.\n(2) Nivel.\n(3) Antigüedad.\n(4) Tipo de Contrato.\nOpción: ";
            cin>>cambio;
            switch (cambio) {
                case 1:
                {
                    cout<<"Nuevo departamento: ";
                    cin>>dato;
                    A.setDepartamento(dato);
                    A.CalculaSalario();
                    N.InsertaOrdenCrec(A);
                    Auxi2=N.BuscaOrdenada(A);
                    N.ImprimeUnNodo(Auxi2);
                    break;
                }
                case 2:
                {
                    cout<<"Nuevo nivel: ";
                    cin>>dato;
                    A.setNivel(dato);
                    A.CalculaSalario();
                    N.InsertaOrdenCrec(A);
                    Auxi2=N.BuscaOrdenada(A);
                    N.ImprimeUnNodo(Auxi2);
                    break;
                }
                case 3:
                {
                    cout<<"Nueva antigüedad: ";
                    cin>>dato;
                    A.setAntiguedad(dato);
                    N.InsertaOrdenCrec(A);
                    Auxi2=N.BuscaOrdenada(A);
                    N.ImprimeUnNodo(Auxi2);
                    break;
                }
                case 4:
                {
                    cout<<"Nuevo tipo de contrato: ";
                    cin>>dato;
                    A.setTipoContrato(dato);
                    N.InsertaOrdenCrec(A);
                    Auxi2=N.BuscaOrdenada(A);
                    N.ImprimeUnNodo(Auxi2);
                    break;
                }
                default:
                    break;
            }
        }
        
    }
    
    void MostrarEmpleados(){
        cout<<"ID"<<setw(18)<<"|NOMBRE"<<setw(40)<<"|DEP."<<setw(7)<<"|NIVEL"<<setw(8)<<"|ANTIG."<<setw(10)<<
        "|CONTRATO"<<setw(14)<<"|SALARIO BASE"<<setw(10)<<"|D. TRAB."<<setw(12)<<"|HRS. EXTRA"<<setw(7)<<"|BONOS"<<setw(7)<<
        "|DESC.";
        N.ImprimeIterativo();
    }
    
    void MostrarUnEmpleado(){
        cout<<"ID del empleado: ";
        int id;
        cin>>id;
        Empleado M(" ",id,0,0,0,0,0,0,0,0,0);
        Auxi2=N.BuscaOrdenada(M);
        N.ImprimeUnNodo(Auxi2);
    }
    
    void CrearNomina(){
        NodoLista<Empleado> *Auxiliar=N.RegresaPrimero(),*Auxi2,*A3,*A4;
        Empleado A,B; int DT, HE; double Bonos, Descuentos;
        while (Auxiliar) {
            A=Auxiliar->RegresaInfo();
            Auxi2=N.BuscaOrdenada(A);
            N.ImprimeUnNodo(Auxi2);
            cout<<"Número de días trabajados: ";
            cin>>DT;
            A.setDiasTrabajados(DT);
            cout<<"Número de horas extra: ";
            cin>>HE;
            A.setHorasExtra(HE);
            cout<<"Bonos: ";
            cin>>Bonos;
            A.setBonos(Bonos);
            cout<<"Descuentos: ";
            cin>>Descuentos;
            A.setDescuentos(Descuentos);
            A.setSalario(Bonos, Descuentos, HE, DT);
            //A.CalculaSalario();
            Auxiliar->setInfo(A);
            Auxiliar=Auxiliar->RegresaLiga();
        }
        A3=N.RegresaPrimero();
        while (A3) {
            B=A3->RegresaInfo();
            A4=N.BuscaOrdenada(B);
            N.ImprimeUnNodo(A4);
            A3=A3->RegresaLiga();
        }
        
    }
    
};



void Menu(){
    
    cout<<"(1) Agregar empleado.\n(2) Eliminar empleado.\n(3) Editar información de empleado.\n(4) Mostrar empleados.\n(5) Mostrar un empleado.\n(6) Crear nómina.\n(7) Salir.\nOpción: ";
    
}


int main() {
    
    //Lista<Empleado> Nomina;
    //Empleado Aux;
    //NodoLista<Empleado> Auxi,*Auxi2;
    NominaC N;
    N.CargarArchivo();
    int Opcion;
    
    do {
        cout<<"\n\t\tSISTEMA DE GESTIÓN DE USUARIOS\n";
        Menu();
        cin>>Opcion;
        switch (Opcion) {
            case 1:
            {
                N.AgregarEmpleado();
                N.guardarElemento();
                break;
            }
            case 2:
            {
                N.EliminarEmpleado();
                N.guardarElemento();
                break;
            }
            case 3:
            {
                N.EditarEmpleado();
                N.guardarElemento();
                break;
            }
            case 4:
            {
                N.MostrarEmpleados();
                break;
            }
            case 5:
            {
                N.MostrarUnEmpleado();
                break;
            }
            case 6:
            {
                N.CrearNomina();
                N.guardarElemento();
                break;
            }
            case 7:
            {
                cout<<"Hasta pronto.\n\n";
                break;
            }
            default:
                cout<<"Opción inválida\n\n";
                break;
                
        }
    } while (Opcion!=7);
    
    N.guardarElemento();
    
    return 0;
    
}

guardar.open("numero.txt",ios::out);
        guardar<<NumeroEmpleados;
        guardar.close();
        guardar.open("datos.txt",ios::out);
            while(Auxiliar){
                A=Auxiliar->RegresaInfo();
            guardar<<A.getID()<<"     "<<A.getNombre()<<"     "<<A.getDepartamento()<<"     "<<A.getNivel()<<"     "<<A.getAntiguedad()<<"     "
                <<A.getTipoContrato()<<"     "<<A.getDiasTrabajados()<<"     "<<A.getHorasExtra()<<"     "<<A.getSalario()<<"     "<<A.getBonos()
                <<"     "<<A.getDescuentos()<<endl;
                Auxiliar=Auxiliar->RegresaLiga();
        
        guardar.close();