package Trabajo;
import javax.swing.JOptionPane;

public class Proyecto
{
	/**
	 * Metodo inicial.
	 */
	public static void main(String[] args)
	{
		try
		{
			int operacion = Integer.parseInt(JOptionPane.showInputDialog("Ingrese una opcion \n"
																	+ "1-Conversion \n"
																	+ "2-Suma \n"
																	+ "3-Resta \n"
																	+ "4-Multiplicacion"));
			menuInicio(operacion);
		}
		catch (Exception err)

		{
		JOptionPane.showMessageDialog(null, "Error","rango Invalido!",JOptionPane.ERROR_MESSAGE);
		}
	}

	/**
	 * Aplicacion para Convercion,sumar,resta o multiplicar Sistemas numericos
	 *
	 * @param operacion
	 * Codigo es de la opreacion
	 * @Autor: Diego Fernando Echverry
	 * @Autor: Pedro Holguin
	 */
	//menu Inicio
	public static void menuInicio(int operacion)
	{

		if (operacion >= 1 && operacion <= 4)
		{
			try
			{
				switch (operacion)
				{
				// Conversion
				case 1:
					int baseOrigen = menuBase(-1);

						String numeroIngresado = ingresarNumero();
						int baseDestino = menuBase(baseOrigen);
						JOptionPane.showMessageDialog(null,convertirNumeroBase(baseOrigen,
								baseDestino, numeroIngresado));

					break;

				// Suma
				case 2:
					int baseOperacion = menuBase(-1);
					String[] datosOperacion = ingresarDatosOperacion();
					JOptionPane.showMessageDialog(null,sumar(
														datosOperacion[0],
														datosOperacion[1],
														baseOperacion));
					break;
				// Resta
				case 3:
					int baseOperacionResta = menuBase(-1);
					String[] datosOperacionResta = ingresarDatosOperacion();

					JOptionPane.showMessageDialog(null,restar(
							datosOperacionResta[0],
							datosOperacionResta[1],
							baseOperacionResta));
					break;

				// Multiplicacion
				case 4:
					int baseOperacionMultiplicacion = menuBase(-1);
					String[] datosOperacionMultiplicacion = ingresarDatosOperacion();

					JOptionPane.showMessageDialog(null,Multiplicar(
							datosOperacionMultiplicacion[0],
							datosOperacionMultiplicacion[1],
							baseOperacionMultiplicacion));
					break;
				}

			} catch (Exception err)
			{
				JOptionPane.showMessageDialog(null, "Error",
						"rango Invalido!",
						JOptionPane.ERROR_MESSAGE);
			}
		} else
		{
			JOptionPane.showMessageDialog(null, "No esta entre las obciones del Menu", "Error!",
					JOptionPane.ERROR_MESSAGE);
		}
	}

	/**
	 *
	 * @param primerOperando
	 * @param segundoOperando
	 * @param baseOperacion
	 * @return
	 */
	private static String sumar(String primerOperando, String segundoOperando,
			int baseOperacion)
	{

		String retorno = "Resultado Suma: ";
		try {
			switch (baseOperacion)
			{
			// Binario
			case 1:
				retorno += sumarBinarios(primerOperando, segundoOperando);
				break;
			// Octal
			case 2:
				retorno += sumarOctal(primerOperando, segundoOperando);
				break;

			// Decimal
			case 3:
				retorno += sumarDecimal(primerOperando, segundoOperando);
				break;

			// Hexadecimal
			case 4:
				retorno += sumarHexadecimal(primerOperando, segundoOperando);
				break;
			}
		} catch (Exception err)
		{
			JOptionPane.showMessageDialog(null, "Error",
					"Has introducido carcateres invalidos!",
					JOptionPane.ERROR_MESSAGE);
		}
		return retorno;
	}

	// Sumar Binarios
	private static String sumarBinarios(String primerOperando,
			String segundoOperando)
	{
		String primerBinario = convertirBinarioADecimal(primerOperando);
		String segundoBinario = convertirBinarioADecimal(segundoOperando);
		int primero = Integer.parseInt(primerBinario);
		int segundo = Integer.parseInt(segundoBinario);
		int operacion = primero + segundo;
		String resultado = "" + operacion;
		return convertirDecimalABinario(resultado);
	}

	// Sumar Octal
	private static String sumarOctal(String primerOperando,
			String segundoOperando)
	{
		String primerOctal = convertirOctalADecimal(primerOperando);
		String segundoOctal = convertirOctalADecimal(segundoOperando);
		int primero = Integer.parseInt(primerOctal);
		int segundo = Integer.parseInt(segundoOctal);
		int operacion = primero + segundo;
		String resultado = "" + operacion;
		return convertirDecimalAoctal(resultado);
	}

	// sumar Decimal
	private static String sumarDecimal(String primerOperando,
			String segundoOperando)
	{
		int primero = Integer.parseInt(primerOperando);
		int segundo = Integer.parseInt(segundoOperando);
		int operacion = primero + segundo;
		String resultado = "" + operacion;
		return resultado;
	}

	// sumar hexadecimal
	private static String sumarHexadecimal(String primerOperando,
			String segundoOperando)
	{
		String primerOctal = convertirHexadecimalADecimal(primerOperando);
		String segundoOctal = convertirHexadecimalADecimal(segundoOperando);
		int primero = Integer.parseInt(primerOctal);
		int segundo = Integer.parseInt(segundoOctal);
		int operacion = primero + segundo;
		String resultado = "" + operacion;
		return convertirDecimalAhexadecimal(resultado);
	}

	/**
	 *
	 * @param primerOperando
	 * @param segundoOperando
	 * @param baseOperacion
	 * @return
	 */
	private static String restar(String primerOperando, String segundoOperando,
			int baseOperacion)
	{

		String retorno = "Resultado Resta: ";

		switch (baseOperacion)
		{
		// Binario
		case 1:
			retorno += restarBinarios(primerOperando, segundoOperando);
			break;
		// Octal
		case 2:
			retorno += restarOctal(primerOperando, segundoOperando);
			break;

		// Decimal
		case 3:
			retorno += restarDecimal(primerOperando, segundoOperando);
			break;

		// Hexadecimal
		case 4:
			retorno += restarHexadecimal(primerOperando, segundoOperando);
			break;
		}

		return retorno;
	}

	// resta Binarios
	private static String restarBinarios(String primerOperando,
			String segundoOperando) {
		String primerBinario = convertirBinarioADecimal(primerOperando);
		String segundoBinario = convertirBinarioADecimal(segundoOperando);
		int primero = Integer.parseInt(primerBinario);
		int segundo = Integer.parseInt(segundoBinario);
		int operacion = primero - segundo;
		String resultado = "" + operacion;
		return convertirDecimalABinario(resultado);
	}

	// restar Octal
	private static String restarOctal(String primerOperando,
			String segundoOperando) {
		String primerOctal = convertirOctalADecimal(primerOperando);
		String segundoOctal = convertirOctalADecimal(segundoOperando);
		int primero = Integer.parseInt(primerOctal);
		int segundo = Integer.parseInt(segundoOctal);
		int operacion = primero - segundo;
		String resultado = "" + operacion;
		return convertirDecimalAoctal(resultado);
	}

	// restar Decimal
	private static String restarDecimal(String primerOperando,
			String segundoOperando) {
		int primero = Integer.parseInt(primerOperando);
		int segundo = Integer.parseInt(segundoOperando);
		int operacion = primero - segundo;
		String resultado = "" + operacion;
		return resultado;
	}

	// restar hexadecimal
	private static String restarHexadecimal(String primerOperando,
			String segundoOperando) {
		String primerOctal = convertirHexadecimalADecimal(primerOperando);
		String segundoOctal = convertirHexadecimalADecimal(segundoOperando);
		int primero = Integer.parseInt(primerOctal);
		int segundo = Integer.parseInt(segundoOctal);
		int operacion = primero - segundo;
		String resultado = "" + operacion;
		return convertirDecimalAhexadecimal(resultado);
	}

	/**
	 *
	 * @param primerOperando
	 * @param segundoOperando
	 * @param baseOperacion
	 * @return
	 */
	private static String Multiplicar(String primerOperando,
			String segundoOperando, int baseOperacion)
	{

		String retorno = "Resultado Multiplicacion: ";

		switch (baseOperacion)
		{
		// Binario
		case 1:
			retorno += MultiplicarBinarios(primerOperando, segundoOperando);
			break;
		// Octal
		case 2:
			retorno += MultiplicarOctal(primerOperando, segundoOperando);
			break;

		// Decimal
		case 3:
			retorno += MultiplicarDecimal(primerOperando, segundoOperando);
			break;

		// Hexadecimal
		case 4:
			retorno += MultiplicarHexadecimal(primerOperando, segundoOperando);
			break;
		}

		return retorno;
	}

	// Multiplicar Binarios
	private static String MultiplicarBinarios(String primerOperando,
			String segundoOperando)
	{
		String primerBinario = convertirBinarioADecimal(primerOperando);
		String segundoBinario = convertirBinarioADecimal(segundoOperando);
		int primero = Integer.parseInt(primerBinario);
		int segundo = Integer.parseInt(segundoBinario);
		int operacion = primero * segundo;
		String resultado = "" + operacion;
		return convertirDecimalABinario(resultado);
	}

	// Multiplicar Octal
	private static String MultiplicarOctal(String primerOperando,
			String segundoOperando)
	{
		String primerOctal = convertirOctalADecimal(primerOperando);
		String segundoOctal = convertirOctalADecimal(segundoOperando);
		int primero = Integer.parseInt(primerOctal);
		int segundo = Integer.parseInt(segundoOctal);
		int operacion = primero * segundo;
		String resultado = "" + operacion;
		return convertirDecimalAoctal(resultado);
	}

	// Multiplicar Decimal
	private static String MultiplicarDecimal(String primerOperando,
			String segundoOperando)
	{
		int primero = Integer.parseInt(primerOperando);
		int segundo = Integer.parseInt(segundoOperando);
		int operacion = primero * segundo;
		String resultado = "" + operacion;
		return resultado;
	}

	// Multiplicar hexadecimal
	private static String MultiplicarHexadecimal(String primerOperando,
			String segundoOperando)
	{
		String primerOctal = convertirHexadecimalADecimal(primerOperando);
		String segundoOctal = convertirHexadecimalADecimal(segundoOperando);
		int primero = Integer.parseInt(primerOctal);
		int segundo = Integer.parseInt(segundoOctal);
		int operacion = primero * segundo;
		String resultado = "" + operacion;
		return convertirDecimalAhexadecimal(resultado);
	}

	/**
	 * toma los datos a operar
	 *
	 */
	public static String[] ingresarDatosOperacion()
	{
		String primerDato = JOptionPane.showInputDialog("Primera Base:");
		String segundoDato = JOptionPane.showInputDialog("Segunda Base:");

		return new String[] { primerDato, segundoDato };
	}

	/**
	 * Metodo que convierte un numero de una base a otra.
	 *
	 * @param baseOrigen
	 *            Base en la que esta escrito el numero que se desea convertir.
	 * @param baseDestino
	 *            Base a la que se desea convertir el metodo.
	 * @param numeroIngresado
	 *            Numero que se desea convertir.
	 * @return El numero convertido a la base destino.
	 */
	public static String convertirNumeroBase(int baseOrigen, int baseDestino,
			String numeroIngresado)
	{

		String retorno = "Resultado: ";

		switch (baseOrigen)
		{
		// Binario
		case 1:

			switch (baseDestino)
			{
			// Octal
			case 2:
				retorno += convertirBinarioAOctal(numeroIngresado);
				break;

			// Decimal
			case 3:
				retorno += convertirBinarioADecimal(numeroIngresado);
				break;

			// Hexadecimal
			case 4:
				retorno += convertirBinarioAHexadecimal(numeroIngresado);
				break;
			}

			break;

		// Octal
		case 2:
			switch (baseDestino)
			{
			// Binario
			case 2:
				retorno += convertirOctalABinario(numeroIngresado);
				break;

			// Decimal
			case 3:
				retorno += convertirOctalADecimal(numeroIngresado);
				break;

			// Hexadecimal
			case 4:
				retorno += convertirOctalAhexdecimal(numeroIngresado);
				break;
			}
			break;

		// Decimal
		case 3:
			switch (baseDestino)
			{
			// Binario
			case 2:
				retorno += convertirDecimalABinario(numeroIngresado);
				break;
			// octal
			case 3:
				retorno += convertirDecimalAoctal(numeroIngresado);
				break;

			// hexadecimal
			case 4:
				retorno += convertirDecimalAhexadecimal(numeroIngresado);
				break;
			}
			break;

		// Hexadecimal
		case 4:
			switch (baseDestino)
			{
			// Binario
			case 2:
				retorno += convertirHexadecimalABinario(numeroIngresado);
				break;
			// octal
			case 3:
				retorno += convertirHexadecimalAOctal(numeroIngresado);
				break;

			// decimal
			case 4:
				retorno += convertirHexadecimalADecimal(numeroIngresado);
				break;
			}
			break;
		}

		System.out.println("baseOrigen " + baseOrigen + " baseDestino "
				+ baseDestino + " numeroIngresado " + numeroIngresado);
		return retorno;
	}

	/**
	 * Pasa un numero de decimal a hexadecimal.
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 *
	 */
	public static String convertirDecimalAhexadecimal(String bas)
	{
		int decimal = Integer.parseInt(bas);
		String digits = "0123456789ABCDEF";
		if (decimal == 0)
			return "0";
		String hexde = "";
		while (decimal > 0) {
			int mod = decimal % 16; // Dígito de la derecha
			hexde = digits.charAt(mod) + hexde; // Concatenación de cadenas
			decimal = decimal / 16;
		}
		return hexde;
	}

	/**
	 *
	 * Pasa un numero de decimal a Octal.
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 */
	public static String convertirDecimalAoctal(String base)
	{
		int inicio = Integer.parseInt(base);
		String acomular = "";
		if (inicio <= 8)
		{
			acomular += inicio;
		} else {
			int div1 = inicio / 8;
			int div2 = div1 / 8;
			int div3 = div2 / 8;
			int div4 = div3 / 8;
			int div5 = div4 / 8;
			int div6 = div5 / 8;
			int div7 = div6 / 8;
			int div8 = div7 / 8;
			int div9 = div8 / 8;
			int[] arreglo = new int[10];
			arreglo[0] = inicio % 8;
			arreglo[1] = div1 % 8;
			arreglo[2] = div2 % 8;
			arreglo[3] = div3 % 8;
			arreglo[4] = div4 % 8;
			arreglo[5] = div5 % 8;
			arreglo[6] = div6 % 8;
			arreglo[7] = div7 % 8;
			arreglo[8] = div8 % 8;
			arreglo[9] = div9 % 8;
			for (int i = arreglo.length - 1; i >= 0; i--)
			{
				if (arreglo[i] != 0)
				{
					acomular += arreglo[i];
				}
			}

		}
		return acomular;
	}

	/**
	 *
	 * Pasa un numero de decimal a Binario.
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 */
	public static String convertirDecimalABinario(String base)
	{
		int baseinte = Integer.parseInt(base);
		String binario = "";
		while (baseinte > 0)
		{
			binario = baseinte % 2 + binario;
			baseinte /= 2;
		}
		return binario;
	}

	/**
	 *
	 * Pasa un numero de hexadecimal A Decimal.
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 */
	public static String convertirHexadecimalADecimal(String base)
	{
		String digitos = "0123456789ABCDEF";
		String decimal = "";
		base = base.toUpperCase();
		int decimalx = 0;
		for (int i = 0; i < base.length(); i++)
		{
			char c = base.charAt(i);
			int d = digitos.indexOf(c);
			decimalx = 16 * decimalx + d;
		}
		decimal += decimalx;
		return decimal;
	}

	/**
	 * Pasa un numero de Octal A Decimal.
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 */
	public static String convertirOctalADecimal(String base)
	{
		String cadenaInver = "";
		int b = 0;
		int c = 0;
		String decimal = "";
		for (int i = base.length() - 1; i >= 0; i--)
		{
			cadenaInver += "" + base.charAt(i);
		}

		for (int i = 0; i < cadenaInver.length(); i++)
		{
			String convertir = "" + cadenaInver.charAt(i);
			b = Integer.parseInt(convertir);
			c += (b * Math.pow(8, i));
		}
		decimal += c;
		return decimal;
	}

	/**
	 * Pasa un numero de Binario A Octal.
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 */
	public static String convertirBinarioAOctal(String base)
	{
		String a = convertirBinarioADecimal(base);
		String octal = convertirDecimalAoctal(a);
		return octal;

	}

	/**
	 * Pasa un numero de Binario A hexadecimal.
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 */
	public static String convertirBinarioAHexadecimal(String base)
	{
		String a = convertirBinarioADecimal(base);
		String hexadecimal = convertirDecimalAhexadecimal(a);
		return hexadecimal;

	}

	/**
	 * Pasa un numero de Binario A hexadecimal.
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 */
	public static String convertirOctalAhexdecimal(String base)
	{
		String a = convertirOctalADecimal(base);
		String hexadecimal = convertirDecimalAhexadecimal(a);
		return hexadecimal;

	}

	/**
	 * Pasa un numero de Octal A Binario.
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 */
	public static String convertirOctalABinario(String base)
	{
		String a = convertirOctalADecimal(base);
		String bianrio = convertirDecimalABinario(a);
		return bianrio;
	}

	/**
	 * Pasa un numero de Hexadecimal A Binario
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 */
	public static String convertirHexadecimalABinario(String base)
	{
		String a = convertirHexadecimalADecimal(base);
		String binario = convertirDecimalABinario(a);
		return binario;

	}

	/**
	 * Pasa un numero de Hexadecimal A Octal
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 */
	public static String convertirHexadecimalAOctal(String base)
	{
		String a = convertirHexadecimalADecimal(base);
		String octal = convertirDecimalAoctal(a);
		return octal;

	}

	/**
	 * Pasa un numero de Binario A Decimal.
	 *
	 * @param numeroIngresado
	 *            Numero a convertir
	 */
	public static String convertirBinarioADecimal(String base)
	{

		String cadenaInver = "";
		int b = 0;
		int c = 0;
		String resulString = "";
		for (int i = base.length() - 1; i >= 0; i--)
		{
			cadenaInver += "" + base.charAt(i);
		}
		double[] arreglo;
		for (int i = 0; i <= cadenaInver.length(); i++)
		{
			arreglo = new double[99];
			arreglo[i] = (Math.pow(2, i));

			for (int m = 0; m < cadenaInver.length(); m++)
			{
				String convertir = "" + cadenaInver.charAt(m);
				b = Integer.parseInt(convertir);
				c += b * arreglo[m];
			}
		}
		resulString += c;
		return resulString;
	}

	/**
	 * Menu para seleccionar base en la operación de conversión.
	 *
	 * @param seleccionado
	 *            Numero seleccionado anteriormente, si se le pasa un -1 se
	 *            mostre todas las opciones.
	 *
	 * @return La base seleccionada por el usuario.
	 */
	public static int menuBase(int seleccionado)
	{

		int baseSeleccionada = -1;
		if (seleccionado == -1)
		{
			// 1 binario, 2 octal, 3 decimal, 4 hexadecimal.

			baseSeleccionada = Integer.parseInt(JOptionPane.showInputDialog("Ingrese una Base \n"
																			+ "1 - Binario \n"
																			+ "2 - Octal \n" + "3 - Decimal \n"
																			+ "4 - Hexadecimal"));
		} else
		{

			String opcionBinario = " Binario \n";
			String opcionOctal =   " Octal \n";
			String opcionDecimal = " Decimal \n";
			String opcionHexadecimal = " Hexadecimal";
			String opcionesSeleccionables = "";
			int contador =2;
			if (seleccionado != 1)
				opcionesSeleccionables +=contador++ +opcionBinario;
			if (seleccionado != 2)
				opcionesSeleccionables +=contador++ + opcionOctal;
			if (seleccionado != 3)
				opcionesSeleccionables +=contador++ + opcionDecimal;
			if (seleccionado != 4)
				opcionesSeleccionables +=contador++ + opcionHexadecimal;

			baseSeleccionada = Integer.parseInt(JOptionPane.showInputDialog("Ingrese una Base \n"
																			+ opcionesSeleccionables));
		}

		if (baseSeleccionada <= 0 || baseSeleccionada > 4)
		{
			JOptionPane.showMessageDialog(null, "Rango Invalido", "Error!",
					JOptionPane.ERROR_MESSAGE);
		}

		return baseSeleccionada;
	}

	public static String ingresarNumero()
	{
		return JOptionPane.showInputDialog("Ingrese el numero en la base origen");
	}

}