//////////////////////////////////////////////////////////////////////////
//
// Fundamentos de Programación
// ETS Informática y Telecomunicaciones
// Universidad de Granada
// Departamento de Ciencias de la Computación e Inteligencia Artificial
// Autor: Juan Carlos Cubero
//
//////////////////////////////////////////////////////////////////////////

// Cuenta Bancaria

#include <iostream>
#include <string>
#include <ctime>

using namespace std;

class Fecha {
private:
   int dia  = 0,
       mes  = 0,
       anio = 0;

   bool EsFechaCorrecta(int el_dia, int el_mes, int el_anio){
      bool es_bisiesto;
      bool es_fecha_correcta;
      const int anio_inferior = 1900;
      const int anio_superior = 2500;
      const int dias_por_mes[12] =
            {31,28,31,30,31,30,31,31,30,31,30,31};

            // Meses de Enero a Diciembre

      es_fecha_correcta =  1 <= el_dia &&
                           el_dia <= dias_por_mes[el_mes - 1] &&
                           1 <= el_mes   &&   el_mes <= 12 &&
                           anio_inferior <= el_anio   &&
                           el_anio <= anio_superior;

      es_bisiesto = (el_anio % 4 == 0 && el_anio % 100 != 0) ||
                     el_anio % 400 == 0;

      if (!es_fecha_correcta && el_mes == 2 && el_dia == 29 && es_bisiesto)
         es_fecha_correcta = true;

      return es_fecha_correcta;
   }
public:
   Fecha(){
      time_t hoy_time_t;
      struct tm * hoy_struct;

      hoy_time_t = time(NULL);
      hoy_struct = localtime ( &hoy_time_t );

      dia  = hoy_struct->tm_mday;
      mes  = hoy_struct->tm_mon + 1;
      anio = hoy_struct->tm_year + 1900 +1;
   }

   Fecha(int el_dia, int el_mes, int el_anio){
      SetDiaMesAnio(el_dia, el_mes, el_anio);
   }

   void SetDiaMesAnio(int el_dia, int el_mes, int el_anio){
      if (EsFechaCorrecta(el_dia, el_mes, el_anio)){
         dia  = el_dia;
         mes  = el_mes;
         anio = el_anio;
      }
      else
         dia = mes = anio = 0;
   }
   int Dia(){
      return dia;
   }
   int Mes(){
      return mes;
   }
   int Anio(){
      return anio;
   }
   string ToString(){
      return to_string(dia) + "/" + to_string(mes)
             + "/" + to_string(anio);
   }
};


class CuentaBancaria{
private:
   double saldo         = 0.0;
   string identificador;  // C++ inicializa los string a ""   
   Fecha  fecha_creacion;

   bool EsCorrectoSaldo(double saldo_propuesto){
      return saldo_propuesto >= 0 && saldo_propuesto <= 10000;
   }
   bool EsCorrectoIdentificador(string identificador_propuesto){
      return (identificador_propuesto.size() == 20 &&
              identificador_propuesto.substr(0,4) == "2031");
   }
   void SetSaldo (double saldo_propuesto){
      if (EsCorrectoSaldo (saldo_propuesto))
         saldo = saldo_propuesto;
   }
public:
   CuentaBancaria(){
   }
   CuentaBancaria(string identificador_cuenta,
                  double saldo_inicial,
                  Fecha la_fecha_de_creacion)
      :fecha_creacion(la_fecha_de_creacion)
   {
      SetIdentificador(identificador_cuenta);
      SetSaldo(saldo_inicial);
   }
   
   void SetIdentificador(string identificador_cuenta){
      if (EsCorrectoIdentificador(identificador_cuenta))
         identificador = identificador_cuenta;
   }
   string Identificador(){
      return identificador;
   }
   double Saldo(){
      return saldo;
   }
   void Ingresa(double cantidad){
      double saldo_resultante;

      if (cantidad > 0){
         saldo_resultante = saldo + cantidad;
         SetSaldo(saldo_resultante);
      }
   }
   void Retira(double cantidad){
      double saldo_resultante;

      if (cantidad > 0){
         saldo_resultante = saldo - cantidad;
         SetSaldo(saldo_resultante);
      }
   }
   void AplicaInteresPorcentual(int tanto_porciento){
      Ingresa (saldo * tanto_porciento / 100.0);
   }
   
   Fecha FechaCreacion(){
      return fecha_creacion;
   }
};



class ColeccionCuentasBancarias{
private:
   static const int NUM_CUENTAS = 1e4;
   CuentaBancaria cjto_cuentas[NUM_CUENTAS];
   int utilizados = 0;
public:
   void Aniade(CuentaBancaria cuenta){
      if (utilizados < NUM_CUENTAS){
         cjto_cuentas[utilizados] = cuenta;
         utilizados++;
      }
   }
   int NumeroCuentas(){
      return utilizados;
   }

   // No construimos ningún método del siguiente tipo
   // ya que no queremos dar la impresión de que
   // desde el main se pudiese hacer algo de la siguiente forma:
   // CuentaBancaria esto_es_una_copia(cuenta.CopiaCuenta(2));
   // esto_es_una_copia.Ingresa(20);
   // Ingresa 20 en la copia, PERO la cuenta de la colección no varía!!
   
   // CuentaBancaria CopiaCuenta(int indice){
   //    return cjto_cuentas[indice];
   // }

   int BuscaIndice(string identificador_a_buscar){
      int indice = -1;
      bool encontrado = false;

      if (utilizados > 0){
         for (int i = 0; i < utilizados && !encontrado; i++){
            if (cjto_cuentas[i].Identificador() == identificador_a_buscar){
               encontrado = true;
               indice = i;
            }
         }
      }

      return indice;
   }
   double Saldo(int indice_cuenta){
      return cjto_cuentas[indice_cuenta].Saldo();
   }
   string Identificador(int indice_cuenta){
      return cjto_cuentas[indice_cuenta].Identificador();
   }
   void Ingresa(int indice_cuenta, double ingreso){
      cjto_cuentas[indice_cuenta].Ingresa(ingreso);
   }
   void Retira(int indice_cuenta, double reintegro){
      cjto_cuentas[indice_cuenta].Retira(reintegro);
   }
};


int main(){
   const string TERMINADOR = "#";
   unsigned int dia, mes, anio;
   double saldo_inicial,
          ingreso_euros;
   string identificador, identificador_a_buscar;
   int indice_cuenta_encontrada;
   ColeccionCuentasBancarias coleccion_cuentas;   // <- La colección se crea fuera del bucle de lectura
   
   cin >> identificador;

   while (identificador != TERMINADOR){
      cin >> dia;
      cin >> mes;
      cin >> anio;
      cin >> saldo_inicial;

      Fecha fecha(dia, mes, anio);
      CuentaBancaria cuenta(identificador, saldo_inicial, fecha);

      coleccion_cuentas.Aniade(cuenta);

      cin >> identificador;
   }

   cin >> identificador_a_buscar;
   cin >> ingreso_euros;
   
   indice_cuenta_encontrada = coleccion_cuentas.BuscaIndice(identificador_a_buscar);

   coleccion_cuentas.Ingresa(indice_cuenta_encontrada, ingreso_euros);
   cout << coleccion_cuentas.Saldo(indice_cuenta_encontrada);
   
   // 20310000000000000001 20 10 1998 200 20310000000000000002 1 1 2010 150 # 20310000000000000001 120
   // Si quisiésemos grabar los datos en fichero tendríamos que volcarlos todos
   // Para evitar este "trasiego" de información, la forma real de trabajar
   // es con Bases de Datos, que se ven en el segundo año de carrera.
}