package cz.frantovo.jaas.sql;

 import com.sun.enterprise.security.auth.realm.BadRealmException;

 import com.sun.enterprise.security.auth.realm.NoSuchUserException;

 import java.sql.Connection;

 import java.sql.PreparedStatement;

 import java.sql.ResultSet;

 import java.sql.SQLException;

 import java.sql.Statement;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.Enumeration;

 import java.util.logging.Level;

 import javax.naming.InitialContext;

 import javax.naming.NamingException;

 import javax.security.auth.login.LoginException;

 import javax.sql.DataSource;

 /**

  * Bezpečnostní doména. Uživatelé jsou uloženi v SQL databázi.

  *

  * @author fiki

  */

 public class SQLRealm extends ParametrizovanýRealm {

 	private static final String AUTH_TYPE = "Ověřuje uživatele proti SQL databázi.";

 	/**

 	 * <p>JNDI jméno datového zdroje – odkazuje na instanci {@linkplain javax.sql.DataSource}</p>

 	 *

 	 * <p>Příklady:</p>

 	 *

 	 * <ul>

 	 * <li><code>jdbc/mojeAplikace</code></li>

 	 * </ul>

 	 */

 	public static final String PARAM_JNDI = "jndi";

 	/** Pokud je nastaveno na "true", nebude se při inicializaci testovat spojení s databází */

 	public static final String PARAM_NETESTOVAT_SPOJENÍ = "netestovat_spojeni";

 	/**

 	 * <p>SQL dotaz pro kontrolu hesla.</p>

 	 *

 	 * <p>Má dva parametry:</p>

 	 * <ol>

 	 * <li>uživatelské jméno</li>

 	 * <li>heslo</li>

 	 * </ol>

 	 *

 	 * <p>Vrací:</p>

 	 * <ul>

 	 * <li>Při úspěšném ověření jednu hodnotu: uživatelské jméno</li>

 	 * <li>Při neexistujícím uživateli nebo špatném hesle: prázdný výsledek (nula řádků)</li>

 	 * <li>Při jiné chybě: vyhazuje výjimku</li>

 	 * </ul>

 	 *

 	 * <p>Příklady:</p>

 	 *

 	 * <ul>

 	 * <li><code>SELECT jmeno FROM uzivatel WHERE jmeno = ? AND heslo = ?</code></li>

 	 * <li><code>SELECT jmeno FROM uzivatel WHERE jmeno = ? AND heslo = sha1(?)</code></li>

 	 * <li><code>SELECT zkontroluj_heslo(?, ?)</code></li>

 	 * </ul>

 	 *

 	 * <p>(hashovací a jiné funkce musí být samozřejmě podporované databází)</p>

 	 */

 	public static final String PARAM_SQL_HESLO = "sql_heslo";

 	/**

 	 * <p>SQL dotaz pro zjištění skupin daného uživatele.</p>

 	 *

 	 * <p>Má jeden parametr: jméno uživatele</p>

 	 *

 	 * <p>Příklady:</p>

 	 *

 	 * <ul>

 	 * <li><code>SELECT nazev FROM skupina WHERE uzivatel = ?</code></li>

 	 * </ul>

 	 */

 	public static final String PARAM_SQL_SKUPINY_UŽIVATELE = "sql_skupiny_uzivatele";

 	/**

 	 * <p>SQL dotaz pro zjištění všech skupin v dané bezpečnostní doméně.</p>

 	 *

 	 * <p>Příklady:</p>

 	 *

 	 * <ul>

 	 * <li><code>SELECT nazev FROM skupina</code></li>

 	 * </ul>

 	 */

 	public static final String PARAM_SQL_SKUPINY_VŠECHNY = "sql_skupiny_vsechny";

 	private String jndiDatovéhoZdroje;

 	private String sqlHeslo;

 	private String sqlSkupinyUživatele;

 	private String sqlSkupinyVšechny;

 	@Override

 	protected void parametrizuj() throws BadRealmException {

 		String jaasContext = getProperties().getProperty(JAAS_CONTEXT_PARAM, SQLLoginModul.VÝCHOZÍ_JAAS_KONTEXT);

 		getProperties().setProperty(JAAS_CONTEXT_PARAM, jaasContext);

 		/** Databázové spojení */

 		jndiDatovéhoZdroje = najdiParametr(PARAM_JNDI, "název datového zdroje");

 		testSpojení();

 		/** SQL dotazy */

 		sqlHeslo = najdiParametr(PARAM_SQL_HESLO, "SQL dotaz pro ověření jména a hesla");

 		sqlSkupinyUživatele = najdiParametr(PARAM_SQL_SKUPINY_UŽIVATELE, "SQL dotaz pro zjištění skupin uživatele");

 		sqlSkupinyVšechny = najdiParametr(PARAM_SQL_SKUPINY_VŠECHNY, "SQL dotaz pro zjištění všech skupin");

 		_logger.log(Level.INFO, "SQLRealm úspěšně parametrizován. JaasContext: {0}, počet parametrů: {1}", new Object[]{getJAASContext(), getProperties().size()});

 	}

 	private void testSpojení() throws BadRealmException {

 		if (Boolean.valueOf(getProperty(PARAM_NETESTOVAT_SPOJENÍ))) {

 			_logger.log(Level.WARNING, "Netestujeme databázové spojení při inicializaci.");

 		} else {

 			try {

 				Connection s = getSpojení();

 				s.close();

 			} catch (NamingException e) {

 				throw new BadRealmException("Datový zdroj s tímto názvem nebyl nalezen: " + jndiDatovéhoZdroje, e);

 			} catch (SQLException e) {

 				throw new BadRealmException("Nepodařilo se navázat spojení s DB datového zdroje: " + jndiDatovéhoZdroje, e);

 			}

 		}

 	}

 	private Connection getSpojení() throws NamingException, SQLException {

 		InitialContext k = new InitialContext();

 		DataSource datovýZdroj = (DataSource) k.lookup(jndiDatovéhoZdroje);

 		return datovýZdroj.getConnection();

 	}

 	@Override

 	public String getAuthType() {

 		return AUTH_TYPE;

 	}

 	/**

 	 * @param uživatel přihlašovací jméno uživatele

 	 * @return seznam skupin, ve kterých se daný uživatel nachází

 	 * @throws NoSuchUserException když uživatel s tímto jménem neexistuje.

 	 */

 	@Override

 	public Enumeration<String> getGroupNames(String uživatel) throws NoSuchUserException {

 		try {

 			return getSkupiny(sqlSkupinyUživatele, uživatel);

 		} catch (NamingException | SQLException e) {

 			String hláška = "Chyba při zjišťování skupin uživatele: " + uživatel + ".";

 			_logger.log(Level.WARNING, hláška, e);

 			throw new NoSuchUserException(hláška);

 		}

 	}

 	/**

 	 * @return seznam všech skupin v této bezpečnostní doméně

 	 * @throws BadRealmException v případě SQL chyby

 	 */

 	@Override

 	public Enumeration getGroupNames() throws BadRealmException {

 		try {

 			return getSkupiny(sqlSkupinyVšechny, null);

 		} catch (NamingException | SQLException e) {

 			throw new BadRealmException("Chyba při zjišťování seznamu všech skupin.", e);

 		}

 	}

 	public Enumeration<String> getSkupiny(String sql, String parametr) throws SQLException, NamingException {

 		Collection<String> skupiny = new ArrayList<>();

 		Connection s = null;

 		PreparedStatement ps = null;

 		ResultSet rs = null;

 		try {

 			s = getSpojení();

 			ps = s.prepareStatement(sql);

 			if (parametr != null) {

 				ps.setString(1, parametr);

 			}

 			rs = ps.executeQuery();

 			while (rs.next()) {

 				skupiny.add(rs.getString(1));

 			}

 			return Collections.enumeration(skupiny);

 		} finally {

 			zavri(s, ps, rs);

 		}

 	}

 	/**

 	 *

 	 * @param jméno uživatelské jméno

 	 * @param heslo heslo

 	 * @return true pokud je jméno a heslo v pořádku | false nikdy – vyhazuje výjimku

 	 * @throws LoginException pokud je jméno nebo heslo neplatné nebo došlo k jiné chybě

 	 */

 	public boolean ověřUživatele(String jméno, char[] heslo) throws LoginException {

 		Connection s = null;

 		PreparedStatement ps = null;

 		ResultSet rs = null;

 		try {

 			s = getSpojení();

 			ps = s.prepareStatement(sqlHeslo);

 			ps.setString(1, jméno);

 			ps.setString(2, new String(heslo));

 			rs = ps.executeQuery();

 			if (rs.next()) {

 				String dbJméno = rs.getString(1);

 				if (dbJméno != null && dbJméno.equals(jméno)) {

 					// OK – úspěšné ověření

 					return true;

 				} else {

 					throw new LoginException("Špatné heslo nebo neexistující uživatel: " + jméno + " != " + dbJméno);

 				}

 			} else {

 				throw new LoginException("Špatné heslo nebo neexistující uživatel: " + jméno);

 			}

 		} catch (NamingException | SQLException e) {

 			String hláška = "SQL chyba při ověřování hesla uživatele: " + jméno + ".";

 			_logger.log(Level.WARNING, hláška, e);

 			throw new LoginException(hláška);

 		} finally {

 			zavri(s, ps, rs);

 		}

 	}

 	/**

 	 * Zavře všechno

 	 *

 	 * @param spojeni DB spojení

 	 * @param prikaz DB dotaz

 	 * @param vysledek DB výsledek

 	 */

 	private static void zavri(Connection spojeni, Statement prikaz, ResultSet vysledek) {

 		if (vysledek != null) {

 			try {

 				vysledek.close();

 			} catch (Exception e) {

 				_logger.log(Level.FINE, "Při zavírání SQL výsledku došlo k chybě.", e);

 			}

 		}

 		if (prikaz != null) {

 			try {

 				prikaz.close();

 			} catch (Exception e) {

 				_logger.log(Level.FINE, "Při zavírání SQL příkazu došlo k chybě.", e);

 			}

 		}

 		if (spojeni != null) {

 			try {

 				spojeni.close();

 			} catch (Exception e) {

 				_logger.log(Level.FINE, "Při zavírání SQL spojení došlo k chybě.", e);

 			}

 		}

 	}

 }