SIMCard.java

/*
*Vamos a diseñar una clase SIMCard que modele el comportamiento de las tarjetas sim 
de móvil desde su emisión, posterior activación y, finalmente, desactivación.
Para ello, nos ajustaremos a las siguientes especificaciones (requisitos funcionales):

-	Una tarjeta SIM tiene asociado un identificador que se formará mediante una 
combinación de una fecha en formato AAAAMMDD más un código numérico de n dígitos. 
Por ejemplo: 2023012509, es un identificador construidor a partir de la fecha 25 de enero de 2023 
y el código numérico de dos  (n = 2) dígitos 09. La clase SIMCard dispondrá de 
una constante que indique cuánto debe valer n.
-	La propia clase SIMCard se encarga de crear un identificador nuevo cada vez que
se genera una nueva tarjeta. Para ello va incrementado de uno en uno la parte 
numérica del identificador. Si se llega al máximo de códigos numéricos, se 
incremente en un día la parte del identificador correspondiente a la fecha y se
reinicia el código numérico a cero. Cuando el identificador se cree por primera 
vez se formará con la fecha de hoy y un código numérico inicial de valor cero.
-	Una tarjeta SIM se crea desactivada y, aunque se le asigna un identificador, 
aún no tendrá asignados ni un DNI ni un Télefono. La única forma de activarla es
asignarle un DNI y un Telefono. Por tanto, activar una tarjeta implica asignarle
un DNI, un Teléfono y pasarla al estado "activada".
-	Por otra parte, una tarjeta SIM podrá ser desactivada sin ninguna restricción 
en cualquier momento. Pero ya nunca más podrá volver a activarse, es decir, las 
SIM son de un solo uso, no obstante, no se eliminará, quedará registrada como 
desactivada, con los datos del último DNI y Telefono que la usó.
-	Una misma persona puede tener varios números de telefono distintos, pero no dos
tarjetas activadas con el mismo numero. Al activar una tarjeta con igual DNI y 
Telefono que otra, la otra se desactiva automáticamente.
-	El mismo número de teléfono no puede pertenecer a varias personas distintas, 
salvo que todas las tarjetas de esas personas estén desactivadas menos una, o sea,
el mismo número de teléfono se puede reusar siempre que sólo esté activo en una 
única tarjeta.
-	Se podrán obtener dos tipos de informes: de una sola tarjeta o de todas las 
tarjetas a la vez que se hayan generado hasta ahora:

Tu trabajo consistirá en implementar la clase SIMCard según las especificaciones 
anteriores. Para ello te proporciono varios recursos: el esqueleto del proyecto 
NetBeans que ya incluye los test unitarios desarrollados, el archivo SIMCard.java
y la biblioteca que contiene a las clases DNI y Telefono (las clases DNI y 
Telefono se implentaron en una tarea anterior).

*/


package iesportada.org.to05;
import bibliotecaDNIyTELEFONO.DNI;
import bibliotecaDNIyTELEFONO.Telefono;
import java.time.LocalDate;
//import static java.time.LocalDate.now;
//import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
//import java.util.Arrays;

/**
 *
 * @author JCGM
 */
public class SIMCard 
  {
  
    // atributos de clase oo instancia
    private static int nCardsCreadas = 0; //contiene cuántas instancias de SIMCard se han creado hasta ahora
    static  SIMCard[] cardsCreadas; //contiene todas las instancias de SIMCard creadas hasta ahora
   //la longitud de este qrray dara ek numero de tarjetas creadas....es redundante
   
    private static final   int  NUMDIGITOS = 1; //deber igual o superior a 1. ¿Cuántos dígitos numéricos se usan en la parte numérica del identificador?
    private static final  DateTimeFormatter FORMATEADORFECHA = DateTimeFormatter.ofPattern("yyyyMMdd");//patrón para formatear los LocalDate a "AAAAMMDD"
  
  // atributod de objetoººººººººººº
    private Telefono telefono; //telefono asociado a la tarjeta
    private DNI dni; //dni asociado a la tarjeta
    private String identificador; //identificador asociado a la tarjeta. Se forma a partir de una fecha y un valor entero
    private boolean activada; //¿tarjeta activada?

  //para generar un identificador único

    static LocalDate ultimaFechaUsada = LocalDate.now(); //ultima fecha usada en la parte de fecha del identificador
//ultima fecha usada en la parte de fecha del identificador
    static int ultimosDigitosUsados = 0;
  
  //último dígito usado en la parte numérica del identificador

  //Constructor
    public SIMCard() 
      {
        SIMCard.nCardsCreadas++;
        this.asignarIdentificador();
        this.agregarCardAArray();
        this.activada=false;
   /*dni=null;
   telefono=null;
   */
      //this.identificador==asignarIdentificador();
      }
    
/*contructor por netbeans
  public SIMCard(Telefono telefono, DNI dni, String identificador, boolean activada, SIMCard[] cardsCreadas)
    {
    this.telefono = telefono;
    this.dni = dni;
    this.identificador = identificador;
    this.activada = activada;
    this.cardsCreadas = cardsCreadas;
    }
  */
  //Asigna un nuevo identificador a la tarjeta recién creada (o sea, es llamado únicamente desde el constructor)
    private void asignarIdentificador() 
      {
        /*if (ultimosDigitosUsados=)*/
        LocalDate hoy = ultimaFechaUsada;
        LocalDate SumaUnDia = hoy.plusDays(1);
    //String prueba = " hola";
        String fechaFormateada = FORMATEADORFECHA.format(hoy);
    //this.identificador=prueba;
    //prueba=this.identificador;
    //identificador=LocalDate.now().toString();
        String prueba=fechaFormateada +getUltimosDigitosUsados() ;
        if (prueba.length()> 9)
          {
            ultimosDigitosUsados=0;
            ultimaFechaUsada=SumaUnDia;
            fechaFormateada = FORMATEADORFECHA.format(SumaUnDia);
          //hoy=SumaUnDia;
            prueba=fechaFormateada +getUltimosDigitosUsados() ;
          }
        this.identificador=prueba;
        this.ultimosDigitosUsados++;
    //ultimaFechaUsada=(LocalDate) FORMATEADORFECHA.parse(prueba.substring(0,8));
  }
  
  //Añade a SIMCard[] la tarjeta recién creada (o sea, es llamado únicamente desde el constructor)
    private void agregarCardAArray() 
      {/*
      if(nCardsCreadas==0)
        {
          cardsCreadas = new SIMCard[1];//la nuevas instancia de objeto lo pone en la posicion 1
          cardsCreadas[0]=this;
        }
      else
        {
          cardsCreadas = Arrays.copyOf(cardsCreadas, cardsCreadas.length+1);//crea una array nuevo, con lo que hay , y añade una
          cardsCreadas[cardsCreadas.length-1] = this;//apunta a mi mismo
        }//araycopy no puede apuntar a null porque rompe progrma nullPointerException  
        /*
         SIMCard[] tempArray = new SIMCard[nCardsCreadas + 1];
        System.arraycopy(cardsCreadas, 0, tempArray, 0, nCardsCreadas);
        tempArray[nCardsCreadas] = this;
        cardsCreadas = tempArray;
        nCardsCreadas++;
        */
      }
  
  //Devuelve el número total de instancias de SIMCard creadas hasta ahora
      static  int getNumeroDeTarjetasCreadas() 
        {
          return SIMCard.nCardsCreadas;
        }
  
  //Devuelve el último dígito usado en la parte numérica del último identificador creado
      static int getUltimosDigitosUsados() 
        {
      //SIMCard.ultimosDigitosUsados= SIMCard.ultimosDigitosUsados++;
          return SIMCard.ultimosDigitosUsados;    
        }
  //Devuelve la última fecha usada en la parte de fecha del último identificador creado
       static  LocalDate getUltimaFechaUsada() 
        {         
          return ultimaFechaUsada;
        }
  
  //Devuelve el identificador de la tarjeta
      String getIdentificador() 
        {
          return this.identificador;
        } 
  
  //Devuelve el télefono de la tarjeta, si fuese null devuelve ""
      String getTelefono() 
        {
          String devuelveTelefono="";
          if(!(this.telefono==null))
            {
              devuelveTelefono=this.telefono.toString();      
            }
          return devuelveTelefono;
        }
  
  //Devuelve el dni de la tarjeta, si fuese null devuelve ""
      String getDNI() 
        {
          String dni="";
          if (this.dni==null)
            {
              dni="";
            }
          else
            {
              dni=this.dni.toString();
            }
          return dni;
        }
  
  //Indica si la tarjeta está Activada o no
      boolean getActivada() 
        {
          return this.activada;
        }
      
  //Desactiva una tarjeta
      void desactiva() 
        {
          if (this.activada=true)
            {
              this.activada=false;
            }
        }
  
  //Devuelve el mayor código numérico que se puede usar en un identificador incluyendo ceros no significativos
      public static String getMaximoCodigoNumerico() 
        {
          int fechaAEntero = 8;
      //int numDigitosAEntero = Integer.parseInt(NUMDIGITOS);
          String unionFechaYNumDigitos = String.valueOf(fechaAEntero+NUMDIGITOS);
          return unionFechaYNumDigitos;
    //String.format(%0" + NUMDIGITOS + "d", ((int) Math.pow(10, NUMDIGITOS));
        }
      
  //Devuelve el valor de la constante FORMATEADORFECHA
      static DateTimeFormatter getFomarteadorFecha() 
        {
      //DateTimeFormatter formato = DateTimeFormatter.ofPattern("YYYYMMDD");
      //LocalDateTime hoy = LocalDateTime.now();
      //String hoyformateado= hoy.format(formato);
      //return formato;
          return FORMATEADORFECHA; 
        }
  
  //Por defecto, las tarjetas se crean desactivadas.
  //Para activar una tarjeta lo que hay que hacer es asignarle un DNI y un Telefono
  //Este método puede provocar las siguientes excepciones
  //   "No se puede activar una SIMCard ya activada"
  //   "Una tarjeta es de un solo uso. Una vez desactivada, NO se puede volver a activar"
  //   "El mismo Teléfono no se puede asignar a dos DNIs distintos"
      void activarTarjeta (String dni, String telefono) throws Exception 
        {
          DNI dniNuevo = new DNI(dni);
      Telefono telefonoNuevo = new Telefono(telefono);
      boolean fin=false;
          /*
      for(int i =0; i< nCardsCreadas; i++)
        {
      if(cardsCreadas[i].getDNI().equals((dniNuevo.toString())))
        {
          if (cardsCreadas[1].getTelefono().equals(telefonoNuevo.toString()))
            {
              if(cardsCreadas[i].getActivada())
                {
                  cardsCreadas[i].desactiva();
                  fin=true;
                }
            }
        }
      else
        {
          if(cardsCreadas[i].getTelefono().equals(telefonoNuevo.toString()))//coincide DNI
            {
              if(cardsCreadas[i].getActivada()) // no coincide DNI si coincide telefono
                {
                  throw new Exception("El mismo Teléfono no se puede asignar a dos DNIs distintos");
                }//coincide DNI, coincide telefono y la otra esta activdada
            }//no coincide dni . si coincide telefono
        }//coincide dni
      if (fin)
        {
          i=nCardsCreadas;
        }
        }
    this.dni=dniNuevo;
      /*
     DNI dniUno = new DNI(dni);
    Telefono telefonoUno = new Telefono(telefono);
        /*
         if (this.activada) {
            throw new Exception("No se puede activar una SIMCard ya activada");
        } else if (this.dni != null) {
            throw new Exception("Una tarjeta es de un solo uso. Una vez desactivada, NO se puede volver a activar");
        } else {
            for (SIMCard card : cardsCreadas) {
                if (card.telefono != null && card.telefono.getNumero().equals(telefono) && !card.dni.getNumero().equals(dni)) {
                    throw new Exception("El mismo Teléfono no se puede asignar a dos DNIs distintos");
                }
            }
            this.dni = new DNI(dni);
            this.telefono = new Telefono(telefono);
            this.activada = true;
            for (SIMCard card : cardsCreadas) {
                if (card != this && card.telefono != null && card.telefono.getNumero().equals(telefono) && card.dni.getNumero().equals(dni)) {
                    card.desactiva();
                }
            }
        }
        */
     // if (dniUno.)
      /*DNI dniDos = new DNI(dni);
      Telefono telefonoDos = new Telefono(telefono);
      SIMCard simCardDos = new SIMCard();
      simcardUno.activada=false;
      simCardDos.activada=false;
      if (!this.activada) //   "No se puede activar una SIMCard ya activada"
        {
          this.activada=true;
        }
      else
        {
          throw new Exception ("No se puede activar un tarjta activada");
        }
      if(!this.activada)
        {
          this.desactiva();
        }
      else
        {
        throw new Exception ("Una tarjeta es de un solo uso. Una vez desactivada, NO se puede volver a activar");
        }
      /*
      if(telefonoUno.equals(telefonoDos))
        {
        }
      else
        {
        throw new Exception ("El mismo Teléfono no se puede asignar a dos DNIs distintos"); 
    }
    */
        }
  
  //Devuelve una cadena con los datos de todas y cada una de las tarjetas instanciadas
  //usando una línea nueva para cada tarjeta
  //Si no se ha creado aún ninguna devolverá una sola línea con
  //el mensaje: "\nNo hay tarjetas creadas"
      static String listadoTarjetas () 
        {
          String mensaje="";
          if (cardsCreadas ==null)
            {
              mensaje="\nNo hay tarjetas creadas";
            }
          else
            {
              mensaje=cardsCreadas.toString();
            }
          return mensaje;
        }
  
  //Devuelve una cadena con los datos de la tarjeta
  
      @Override
      public String toString() 
        {
          String mensaje="";
          if (SIMCard.this.activada=true)
            {
              
               mensaje = "Identificador: " + SIMCard.this.getIdentificador() + ", Activada: SI, DNI: " + SIMCard.this.getDNI()+ ", Telefono: "+ SIMCard.this.getTelefono();
              //mensaje = "la tarjeta ha sido cread con numero " + SIMCard.getUltimosDigitosUsados() + "con ID " + getIdentificador();
              
            }
          mensaje = "Identificador: " + SIMCard.this.getIdentificador() + ", Activada: NO, DNI: " + this.getDNI()+ ", Telefono: "+ this.getTelefono();
          //mensaje="Identificador: " + SIMCard.this.getIdentificador() + ", Activada: NO, DNI: 95317770C, Telefono: (+34) 999 999 982";
          //mensaje="Identificador: " + SIMCard.this.getIdentificador() + ", Activada: NO, DNI: " + this.getDNI() + ", Telefono: " + this.getTelefono();
          //mensaje="Identificador: " + SIMCard.this.getIdentificador() + ", Activada:" NO, DNI: 95317770C, Telefono: (+34) 999 999 982"; 
          return mensaje;
        }
    }//class