package pe.edu.unp.rol;
 
public abstract class Jugador {
 
	private String nombre;
	private Double poder;
	private Integer vida;
 
	public Jugador() {
		this("",0d,0);
	}
 
	public Jugador(String nombre, Double poder, Integer vida) {
		this.nombre = nombre;
		this.poder = poder;
		this.vida = vida;
	}
 
	public String getNombre() {
		return this.nombre;
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public Double getPoder() {
		return this.poder;
	}
 
	public void setPoder(Double poder) {
		this.poder = poder;
	}
 
	public Integer getVida() {
		return vida;
	}
 
	public void setVida(Integer vida) {
		this.vida = vida;
	}
 
 
}

package pe.edu.unp.rol;
 
public class Soldado extends Jugador {
 
	public Soldado() {
		super();
	}
 
	public Soldado(String nombre, Double poder, Integer vida) {
		super(nombre,poder,vida);
	}
 
}

package pe.edu.unp.rol;
 
public class Campesino extends Jugador {
 
	public Campesino() {
		super();
	}
 
	public Campesino(String nombre, Double poder, Integer vida) {
		super(nombre,poder,vida);
	}
 
 
}

package pe.edu.unp.rol;
 
public class Mago extends Jugador {
 
	private Double magia;
 
	public Mago() {
		super();
	}
 
	public Mago(String nombre, Double poder, Integer vida, Double magia) {
		super(nombre,poder,vida);
		this.magia = magia;
	}
 
	public Double getMagia() {
		return magia;
	}
 
	public void setMagia(Double magia) {
		this.magia = magia;
	}
}

package pe.edu.unp.rol;
 
public class Obrero extends Jugador {
 
	public Obrero() {
		super();
	}
 
	public Obrero(String nombre, Double poder, Integer vida) {
		super(nombre,poder,vida);
	}
 
 
}

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
public class Test {
 
	private final static String paquete = "pe.edu.unp.rol."; // nombre del paquete que contiene las clases
 
	/**
	 * Este metodo genera en tiempo de ejecución instancias de 4 clases distintas, con nombres aleatorios
	 * y sus propiedades poder, vida y en caso la instancia sea tipo 'Mago', agrega la magia, todos aleatorios.
	 * 
	 * @return List<Jugador>
	 * @throws InstantiationException
	 * @throws IllegalAccessException
	 * @throws IllegalArgumentException
	 * @throws InvocationTargetException
	 * @throws NoSuchMethodException
	 * @throws SecurityException
	 * @throws ClassNotFoundException
	 */
	public List<Jugador> getJugadores() throws InstantiationException, IllegalAccessException, IllegalArgumentException,
	InvocationTargetException, NoSuchMethodException, SecurityException, ClassNotFoundException {
		List<Jugador> listaObjetos = new ArrayList<>(); // lista que almacenara las instancias de las clases
		String[] clases = {"Soldado","Campesino","Mago","Obrero"};
		String[] nombres = {"Halz","Orion","Violetus","Orks","Kalz","Pivot","Nerth","Seth","Vandal"};
 
		int numeroObjetosAzar = new Random().nextInt(50)+1; // se crearan maximo 50 instancias con los 4 tipos de clases
 
		for(byte i=0; i<numeroObjetosAzar; i++) {
			// valores aleatorios que se setearan a las instancias
			String claseAleatoria = clases[ (1 + new Random().nextInt(3)) ];
			String nombreAleatorio = nombres[ (1 + new Random().nextInt(8)) ];
			Double poderAleatorio = Math.floor(1 + Math.random() * 100);
			Double magiaAleatoria = Math.floor(1 + Math.random() * 100);
			Integer vidaAleatoria = 1 + new Random().nextInt(100);
 
			/** de acuerdo a la clase, obtenemos una instancia de acuerdo a la clase que especificamos
			 por medio de 'Class.forName(clase)' seguido de 'getConstructor()' que obtiene el
			 constructor de dicha clase y le pasamos los parametros.
			 Esto se puede hacer perfectamente con el operador new Clase(parametros). La diferencia
			 es que Class.forName() se usa cuando no se sabe que clase instanciar si no hasta cuando
			 las circunstancias en tiempo de ejecucion lo determine. new lo usamos cuando sabemos de
			 antemano que clase instanciar.*/
			switch(claseAleatoria) {
			case "Soldado": listaObjetos.add((Soldado)Class.forName(paquete+claseAleatoria)
					.getConstructor(String.class,Double.class,Integer.class).newInstance(nombreAleatorio,poderAleatorio,vidaAleatoria));
			break;
			case "Campesino": listaObjetos.add((Campesino)Class.forName(paquete+claseAleatoria)
					.getConstructor(String.class,Double.class,Integer.class).newInstance(nombreAleatorio,poderAleatorio,vidaAleatoria));
			break;
			case "Mago": listaObjetos.add((Mago)Class.forName(paquete+claseAleatoria)
					.getConstructor(String.class,Double.class,Integer.class,Double.class).newInstance(nombreAleatorio,poderAleatorio,vidaAleatoria,magiaAleatoria));
			break;
			default : listaObjetos.add((Obrero)Class.forName(paquete+claseAleatoria)
					.getConstructor(String.class,Double.class,Integer.class).newInstance(nombreAleatorio,poderAleatorio,vidaAleatoria));
			}
		}
 
 
		return listaObjetos;
	}
 
	public static void main(String[] args) {
		Test test = new Test();
 
		/**
		 *  Ejemplo de recorrido. Generalizamos con 'Jugador' porque todas sus subclases:
		 * Soldado, Campesino, Mago y Obrero al heredar de Jugador son tambien un Jugador.
		 * Recuerda que la herencia es una relacion es un. El operador 'instaceof' es util
		 * para saber si una objeto es de una clase dada: objeto instaceof clase. Esto
		 * retorna true si es el objeto es una instancia de la clase o false si no lo es.
		 */
		try {
			for(Jugador e : test.getJugadores()) {
				System.out.println("Tipo:\t"+e.getClass().getSimpleName());
				System.out.println("Nombre:\t"+e.getNombre());
				System.out.println("Poder:\t"+e.getPoder());
				System.out.println("Vida:\t"+e.getVida());
				if(e.getClass().getSimpleName().equals("Mago")) {
					Mago mago = (Mago) e;
					System.out.println("Magia:\t"+mago.getMagia());
				}
 
			}
		} catch (InstantiationException | IllegalAccessException
				| IllegalArgumentException | InvocationTargetException
				| NoSuchMethodException | SecurityException
				| ClassNotFoundException e) {
				e.printStackTrace();
				System.err.println(e.getLocalizedMessage());
		}
 
 
	}