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);

			}

		}

	}

}