package com.tarisan.generador.oracle;


import com.tarisan.generador.Tabla;
import com.tarisan.generador.Campo;
import com.tarisan.generador.Registro;
import com.tarisan.generador.Dato;
import com.tarisan.generador.UtilidadesGeneradorBD;
import com.tarisan.generador.ObtenerTablasBD;

import java.util.Vector;
import java.sql.*;

public class ObtenerTablasBDOracle
{
	
	/**
		Conexión a Oracle
	*/
	private Connection conn;


	/**
	*	constructor de la clase
	*/
	public ObtenerTablasBDOracle(Connection newConn)
	{
		conn = newConn;
	}
	
	
	/**
	*	metodo que ,dado un array de Strings con los nombres de 
	*	las tablas devuelve un vector de objetos Tabla
	*/
	public Vector getTablasBD(String[] nombresTabla, int tipo)
	{
		Vector vectorTablas = new Vector();
		Statement stmt = null;

		try
		{	
			stmt = conn.createStatement();
			switch(tipo)
			{
				case ObtenerTablasBD.JAVA:
				{
					vectorTablas = getEstructura(nombresTabla, stmt);
					break;
				}
				case ObtenerTablasBD.XML:
				{
					vectorTablas = getEstructura(nombresTabla, stmt);
					break;
				}
				case ObtenerTablasBD.DATOS_XML:
				{
					vectorTablas = getValores(nombresTabla, stmt);
					break;
				}
				case ObtenerTablasBD.DOC:
				{
					vectorTablas = getEstructura(nombresTabla, stmt);
					break;
				}
				case ObtenerTablasBD.SQL:
				{
					vectorTablas = getEstructura(nombresTabla, stmt);
					break;
				}
				case ObtenerTablasBD.HTML:
				{
					vectorTablas = getEstructura(nombresTabla, stmt);
					break;
				}
			}
		}
		catch(Exception e)
		{
			System.err.println(e);
		}
		
		//devuelvo el vector de tablas
		vectorTablas.trimToSize();
		return vectorTablas;	
	}
	
	
	private Vector getEstructura(String[] nombresTabla, Statement stmt) throws Exception
	{
		//Voy a ir recorriendo las tablas de la BD y sus correspondientes campos
		Tabla tabla;
		String nombre, nombreOriginal;
		Vector vectorCampos = null, vectorKeys = null;
		Vector vectorTablas = new Vector();
		ResultSet rs = null,rsPKeys = null;
		ResultSetMetaData rsMetaData = null;
		Campo campo;
	
		for (int k=0; k < nombresTabla.length ; k++)
		{	
			tabla = new Tabla();
			vectorCampos = new Vector();
			
			// nombre original de la tabla
			nombreOriginal = nombresTabla[k];
			tabla.setNombreOriginal(nombreOriginal);
				
			//nombre de la tabla / del javabean
			nombre = UtilidadesGeneradorBD.getNombreTabla( nombreOriginal );
			tabla.setNombre(nombre);
			
			
			//Columnas que son clave primaria
			vectorKeys = new Vector();
			String[] keyColumns = null;

			StringBuffer queryPKeys = new StringBuffer();
			queryPKeys.append("SELECT USER_CONS_COLUMNS.COLUMN_NAME");
			queryPKeys.append(", USER_CONSTRAINTS.CONSTRAINT_NAME");
			queryPKeys.append(", TAB.TABTYPE");
			queryPKeys.append(" FROM USER_CONS_COLUMNS, USER_CONSTRAINTS, TAB");
			queryPKeys.append(" WHERE USER_CONS_COLUMNS.TABLE_NAME = '" +nombreOriginal+ "'");
			queryPKeys.append(" AND USER_CONSTRAINTS.CONSTRAINT_TYPE = 'P'");
			queryPKeys.append(" AND USER_CONSTRAINTS.CONSTRAINT_NAME = USER_CONS_COLUMNS.CONSTRAINT_NAME");
			queryPKeys.append(" AND USER_CONSTRAINTS.TABLE_NAME = TAB.TNAME");
			queryPKeys.append(" ORDER BY USER_CONS_COLUMNS.POSITION");

			String nombrePKey = "";
			String tipoTabla = "";

			rsPKeys = stmt.executeQuery(queryPKeys.toString());
			while(rsPKeys.next())
			{	
//				vectorKeys.addElement(rsPKeys.getString("COLUMN_NAME"));
				vectorKeys.addElement(rsPKeys.getString(1));
				nombrePKey = rsPKeys.getString(2);
				tipoTabla = rsPKeys.getString(3);
			}
			vectorKeys.trimToSize();
			keyColumns = new String[ vectorKeys.size() ];
			vectorKeys.copyInto( keyColumns );
			
			//Tipo de la tabla oracle (tabla o vista)
			tabla.setTipoTabla(tipoTabla);

			//Tomo todos los campos de esta tabla
			rs = stmt.executeQuery("SELECT * FROM "+ nombreOriginal );
			rsMetaData = rs.getMetaData();
		
		
			//empiezo a recorrer los campos de la tabla 
			for (int i = 1 ; i <= rsMetaData.getColumnCount() ; i++)
			{				
				campo = new Campo();				
				
				// Nombre original del campo
				String nombreOriginalCampo = rsMetaData.getColumnName(i);
				campo.setNombreOriginal( nombreOriginalCampo );
				
								
				//Nombre del campo (es decir, de la propiedad del bean)
				campo.setNombre( UtilidadesGeneradorBD.getNombreCampo( nombreOriginalCampo ));
				
			
				// tipo (java) de campo y largo segun tipo
				String tipoOracle = rsMetaData.getColumnTypeName(i);					
				tipoOracle.trim();
				tipoOracle.toUpperCase();
				
				if( tipoOracle.equals("CHAR"))
				{
					campo.setLongitudOracle(String.valueOf(rsMetaData.getColumnDisplaySize(i)));
					campo.setTipoOracle("CHAR");
					campo.setTipo("String");
					campo.setLargo( rsMetaData.getColumnDisplaySize(i) );
				}
				else if(tipoOracle.equals("CHARACTER"))
				{
					campo.setLongitudOracle(String.valueOf(rsMetaData.getColumnDisplaySize(i)));
					campo.setTipoOracle("CHARACTER");
					campo.setTipo("String");
					campo.setLargo( rsMetaData.getColumnDisplaySize(i) );
				}
				else if( tipoOracle.equals("DATE") ) 
				{
					campo.setLongitudOracle("");
					campo.setTipoOracle("DATE");
					campo.setTipo("java.sql.Date");
					campo.setLargo( rsMetaData.getColumnDisplaySize(i) );

				}
				else if( tipoOracle.equals("LONG") ) 
				{
					//como tipo memo
					campo.setLongitudOracle("");
					campo.setTipoOracle("LONG");
				}
				else if( tipoOracle.equals("LONG RAW") ) 
				{
					campo.setLongitudOracle("");
					campo.setTipoOracle("LONG RAW");
					campo.setTipo("long");
				}
				else if( tipoOracle.equals("MLSLABEL") ) 
				{
					//no se que es esto
					campo.setLongitudOracle("");
					campo.setTipoOracle("MLSLABEL");
				}
				else if( tipoOracle.equals("NUMBER") ) 
				{
					campo.setLongitudOracle(String.valueOf(rsMetaData.getPrecision(i)));
					if (rsMetaData.getScale(i) > 0)
					{
						campo.setLongitudOracle(campo.getLongitudOracle() + "," + String.valueOf(rsMetaData.getScale(i)));
					}
					campo.setTipoOracle("NUMBER");
				//	campo.setScale( rsMetaData.getScale(i) );
				//	campo.setPrecision( rsMetaData.getPrecision(i) );
					if(rsMetaData.getScale(i) != 0)
					{
						campo.setTipo("double");
					}
					else
					{
						if(rsMetaData.getPrecision(i) == 0)
						{
							campo.setTipo("double");
						}
						else
						{
							if(rsMetaData.getPrecision(i) < 10)
							{
								campo.setTipo("int");
							}
							else
							{
								//campo.setTipo("long");
								campo.setTipo("double");
							}
						}
					}
					campo.setLargo(rsMetaData.getColumnDisplaySize(i));
				}
				else if( tipoOracle.equals("RAW") ) 
				{
					//no se que es esto
					campo.setLongitudOracle("");
					campo.setTipoOracle("RAW");
				}
				else if( tipoOracle.equals("RAW MLSLABEL") ) 
				{
					//no se que es esto
					campo.setLongitudOracle("");
					campo.setTipoOracle("RAW MLSLABEL");
				}
				else if( tipoOracle.equals("ROWID") ) 
				{
					//no se que es esto
					campo.setLongitudOracle("");
					campo.setTipoOracle("ROWID");
				}
				else if(tipoOracle.equals("VARCHAR2")) 
				{
					campo.setLongitudOracle(String.valueOf(rsMetaData.getColumnDisplaySize(i)));
					campo.setTipoOracle("VARCHAR2");
					campo.setTipo("String");
					campo.setLargo( rsMetaData.getColumnDisplaySize(i) );
				}
				else if(tipoOracle.equals("VARCHAR")) 
				{
					campo.setLongitudOracle(String.valueOf(rsMetaData.getColumnDisplaySize(i)));
					campo.setTipoOracle("VARCHAR");
					campo.setTipo("String");
					campo.setLargo( rsMetaData.getColumnDisplaySize(i) );
				}
				
				// Campo requerido o no	
				if( rsMetaData.isNullable(i) == 0)
					campo.setRequerido( true );
				else
					campo.setRequerido( false );
				
				
				//	campo primay key o no
				for( int j = 0; j < keyColumns.length; j++)
				{
					if( (campo.getNombreOriginal()).equals(keyColumns[j]))
					{
						campo.setClave( true );
						campo.setClaveOracle(nombrePKey + " (" + String.valueOf(j+1) + "º)");
						break;
					}
				}
							
				// añado el campo al vector de campos
				vectorCampos.addElement(campo);
				
				
			}//fin del for de campos
			
			//añado la tabla al vector de tablas
			tabla.setCampos(vectorCampos);
			vectorTablas.addElement(tabla);
					
		}//fin del for de tablas

		return vectorTablas;	
	}
	
	private Vector getValores(String[] nombresTabla, Statement stmt) throws Exception
	{
		//Voy a ir recorriendo las tablas de la BD y sus correspondientes campos
		Registro registro;
		String nombre, nombreOriginal;
		Vector vectorDatos = null;
		Vector vectorRegistros = new Vector();
		Dato dato;
		String nombreOriginalDato;
		ResultSet rs = null;
		ResultSetMetaData rsMetaData = null;
		String tipoOracle;

		for (int k=0; k < nombresTabla.length ; k++)
		{	
			// nombre original de la tabla
			nombreOriginal = nombresTabla[k];
			
			//Tomo todos los campos de esta tabla
			rs = stmt.executeQuery("SELECT * FROM " + nombreOriginal );
			rsMetaData = rs.getMetaData();
		
			//Empiezo a recorrer los registros de datos de la tabla 
			while(rs.next())
			{
				registro = new Registro();
				vectorDatos = new Vector();
				
				registro.setNombreOriginal( nombreOriginal );
					
				//nombre de la tabla / del javabean
				nombre = UtilidadesGeneradorBD.getNombreTabla( nombreOriginal );
				registro.setNombre( nombre );

				for(int i = 1; i <= rsMetaData.getColumnCount(); i++)
				{				
					dato = new Dato();
	
					nombreOriginalDato = rsMetaData.getColumnName(i);
					dato.setNombreOriginal( nombreOriginalDato );
									
					//Nombre del campo (es decir, de la propiedad del bean)
					dato.setNombre( UtilidadesGeneradorBD.getNombreCampo( nombreOriginalDato ));

					//Valor del campo
					dato.setValor(rs.getString(i));
					
					//Tipo(java) de campo
					tipoOracle = rsMetaData.getColumnTypeName(i).trim().toUpperCase();
					if( tipoOracle.equals("CHAR") || tipoOracle.equals("CHARACTER") )
					{
						dato.setClase("Character");
					}
					else if( tipoOracle.equals("DATE") ) 
					{
						dato.setClase("java.sql.Date");
						dato.setValor(UtilidadesGeneradorBD.formatearFecha((String)dato.getValor()));
					}
					else if( tipoOracle.equals("LONG") ) 
					{
						//como tipo memo
					}
					else if( tipoOracle.equals("LONG RAW") ) 
					{
						dato.setClase("Long");
					}
					else if( tipoOracle.equals("MLSLABEL") ) 
					{
						//no se que es esto
					}
					else if( tipoOracle.equals("NUMBER") ) 
					{
						if(rsMetaData.getScale(i) != 0)
						{
							dato.setClase("Double");
						}
						else
						{
							if(rsMetaData.getPrecision(i) == 0)
							{
								dato.setClase("Double");
							}
							else
							{
								if(rsMetaData.getPrecision(i) < 10)
								{
									dato.setClase("Integer");
								}
								else
								{
									//dato.setClase("Long");
									dato.setClase("Double");
								}
							}
						}
					}
					else if( tipoOracle.equals("RAW") ) 
					{
						//no se que es esto
					}
					else if( tipoOracle.equals("RAW MLSLABEL") ) 
					{
						//no se que es esto
					}
					else if( tipoOracle.equals("ROWID") ) 
					{
						//no se que es esto
					}
					else if( tipoOracle.equals("VARCHAR2") || tipoOracle.equals("VARCHAR")) 
					{
						dato.setClase("String");
					}

					// añado el dato al vector de datos
					vectorDatos.addElement(dato);
				}//fin del for de registros

				//añado la tabla al vector de registros
				registro.setDatos(vectorDatos);
				vectorRegistros.addElement(registro);
			}
			
		}//fin del for de tablas

		return vectorRegistros;	
	}

	/**
	*	Accede a la BD y devuelve los nombres de todas las tablas
	*/
	public String[] getNombresAllTablasBD()
	{	
		String[] resultado = null;
		Vector vectorNombres = new Vector();
		
		//Busco los nombres de las tablas de la BD
		Statement stmt; 
		ResultSet rs;
		try
		{
			//tomo los nombres de la tabla
			stmt = conn.createStatement();
//			rs = stmt.executeQuery( "SELECT TABLE_NAME FROM USER_TABLES" );
			rs = stmt.executeQuery( "SELECT TNAME FROM TAB" );
			while(rs.next())
			{
//				vectorNombres.addElement( rs.getString("TABLE_NAME") );
				vectorNombres.addElement( rs.getString("TNAME") );
			}
			
			// Copio los elementos del vector en el array
			vectorNombres.trimToSize();
			resultado = new String[ vectorNombres.size() ];
			vectorNombres.copyInto(resultado);
			
		}
		catch(SQLException sqle)
		{
			System.err.println( sqle );
		}
	
		//devuelvo el resultado
		return resultado;
	}

	
	
	
}