package utils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.concurrent.ThreadLocalRandom;


import utils.GeneralUtils;
import database.MainConnection;
import entity.User;

public class UserUtil extends MainConnection {

	public static void main(String[] args ) throws Exception {
		//test da cancellare
		//registerUser("mattia3","prova2", hash("password"), "mattia", "paccamiccio", "1994-12-01", "unicam");

		//test da cancellare
		//passwordRecovery("mattia.paccamiccio@studenti.unicam.it");

		//test da cancellare
		//int userId=0;
		//userId=getIDFromEmail("zeropaccato@gmail.com");
		//System.out.println(userId);

	}

	//Metodo che dato in input l'user lo inserisce nel database per la registrazione, aggiungere creazione repository privata
	public static Boolean registerUser(User user) throws Exception {
		try{
			Connection con = getConnection();

			//la password viene criptata
			String hashedPassword = GeneralUtils.hash(user.getPassword());

			PreparedStatement registerUserQuery = con.prepareStatement("INSERT INTO users (Username, Email, Password, Name, Surname, BirthDate, Affiliation) VALUES (?,?,?,?,?,?,?)");
			registerUserQuery.setString(1, user.getUsername());
			registerUserQuery.setString(2, user.getEmail());
			registerUserQuery.setString(3, hashedPassword);
            registerUserQuery.setString(4, user.getName());
            registerUserQuery.setString(5, user.getSurname());
            registerUserQuery.setString(6, user.getBirthdate());
            registerUserQuery.setString(7, user.getAffiliation());
           	registerUserQuery.executeUpdate();

			System.out.println("lo user è:"+user.getName()+"++"+user.getSurname()+"++"+user.getBirthdate()+"++"+user.getPassword()+"++"+user.getAffiliation()+"++"+user.getEmail());
			System.out.println("registrazione eseguita con successo");

			int userID = getIDFromEmail(user.getEmail());
			createRepositoryForUser(userID);

			con.close();
			return true;
		} catch(Exception e) {
			System.out.println(e);
		}
		System.out.println("registrazione fallita");
		return false;
	}

	//Dato in input l'username e la password, esegue il login dell'utente se già esiste nel database
	public static Boolean userLogin(String username, String password) throws Exception {
		Boolean bool = true;
		try{
			Connection con = getConnection();

			//la password viene criptata
			String hashedPassword = GeneralUtils.hash(password);

			PreparedStatement query = con.prepareStatement("SELECT * FROM users WHERE Username=? AND Password=?");
			query.setString(1, username);
			query.setString(2, hashedPassword);
			ResultSet result = query.executeQuery();

			//ArrayList<String> array = new ArrayList<String>();
			if(result.next()) {
				System.out.println("login effettuato");
				con.close();
				bool = true;
			}else{
				System.out.println("login fallito");
				con.close();
				bool = false;
			}
		}catch(Exception e) {
			System.out.println(e);
		}
		return bool;
	}

	public static Boolean passwordRecovery(String email) throws Exception {
		Boolean bool = null;

		try{
			Connection con = getConnection();

			PreparedStatement query1 = con.prepareStatement("SELECT UserID FROM users WHERE Email=?");
			query1.setString(1, email);
			ResultSet result1 = query1.executeQuery();

			String userID = null;

			if(result1.next()) {
				userID = result1.getString("UserID");
				System.out.println(userID);
			}
			else {
				System.out.println("Email non trovata");
				con.close();
				return false;
			}


			PreparedStatement query2 = con.prepareStatement("INSERT INTO passwordrecovery (UserID, Token, Used) VALUES (?,?,?)");
			query2.setString(1, userID);
			query2.setString(2, GeneralUtils.generateRandomString());
			query2.setString(3, "false");


			int result2 = query2.executeUpdate();

			if(result2 > 0) {
				System.out.println("query eseguita");
			}
			else {
				System.out.println("query non eseguita");
			}
			con.close();
		} catch(Exception e) {
			System.out.println(e); }
		return bool;
	}

	//Restituisce "true" se il determinato username è già stato utilizzato, "false" altrimenti
	public static Boolean isUsernameUsed(String username) throws Exception {
		Boolean bool = false;
		Connection con = getConnection();
		PreparedStatement query1 = con.prepareStatement("SELECT UserID FROM users WHERE username=?");
		query1.setString(1, username);
		ResultSet result1 = query1.executeQuery();
		if(result1.next()) {
			bool=true;
		}
		con.close();
		return bool;
	}

	//Restituisce "true" se la determinata Email è già stata utilizzata, "false" altrimenti
	public static Boolean isEmailUsed(String e_mail) throws Exception {
		Boolean bool = false;
		Connection con = getConnection();
		PreparedStatement query1 = con.prepareStatement("SELECT UserID FROM users WHERE email=?");
		query1.setString(1, e_mail);
		ResultSet result1 = query1.executeQuery();
		if(result1.next()) {
			bool=true;
		}
		con.close();
		return bool;
	}

	//Restituisce l'id dell'utente a cui è associata una determinata e-mail, se viene restiuito "0" vuol dire
	//che non esiste nessun utente con quella e-mail
	public static int getIDFromEmail(String e_mail) throws Exception {
		int id=0;
		Connection con = getConnection();
		PreparedStatement query1 = con.prepareStatement("SELECT UserID FROM users WHERE email=?");
		query1.setString(1, e_mail);
		ResultSet result1 = query1.executeQuery();
		if(result1.next()) {
			//potrebbe non essere 1 ma 0, da controllare
			id=result1.getInt(1);
		}
		con.close();
		return id;
	}

	//restituisce l'ID dell'utente associato al token dato, se l'utente non esiste restituisce 0
	public static int getUserIDFromToken(String token) throws Exception {
		int id_utente = 0;
		Connection con = getConnection();
		PreparedStatement query1 = con.prepareStatement("SELECT UserID FROM passwordrecovery WHERE token=?");
		query1.setString(1, token);
		ResultSet result1 = query1.executeQuery();
		if(result1.next()) {
			id_utente=result1.getInt(1);
		}
		con.close();
		return id_utente;
	}

	//Restituisce la stringa contenente il nuovo token, nel caso in cui non sia riuscita a generare un nuovo
	//token restituisce la stringa vuota
	public static String createTokenForUser(int userID) throws Exception {
		Connection con = getConnection();

		//Used è zero invece che false perché nel database viene utilizzato il tipo tinyInt
		PreparedStatement insertQuery = con.prepareStatement("INSERT INTO passwordrecovery (UserID, Token, Used) VALUES (?,?,0)");
		String userIDString = "";
		userIDString = Integer.toString(userID);
		insertQuery.setString(1, userIDString);

		/////////////////////////////////////////////////////////////////////////////////
		////    DA CAMBIARE    /////////////////////////////////////////////////////////
		/////////////////////////////////////////////////////////////////////////////////

		String token = GeneralUtils.generateRandomString();

		//Genera token come stringhe casuali fino a quando una di queste stringhe
		//non è nel database
		while(isTokenInDatabase(token)){
			token = GeneralUtils.generateRandomString();
		}

		insertQuery.setString(2, token);

		int result2 = insertQuery.executeUpdate();

		if(result2==0) {
			token="";
		}
		con.close();
		return token;
	}

	//Cambia la password di un utente, se la password è stata cambiata con successo allora viene
	//restiuito il valore true, altrimenti false
	public static Boolean changeUserPassword(int userID, String password) throws Exception {

		Connection con = getConnection();
		Boolean hasPasswordChanged=false;
		String cryptedPassword=GeneralUtils.hash(password);
		PreparedStatement changePasswordQuery = con.prepareStatement("UPDATE users SET password=? WHERE UserID=?");
		changePasswordQuery.setString(1, cryptedPassword);
		changePasswordQuery.setString(2, Integer.toString(userID));
		int affectedRecords = changePasswordQuery.executeUpdate();
		if(affectedRecords>0) {
			hasPasswordChanged = true;
			setAllTokenOfUserAsUsed(userID);
		}
		System.out.println("Password has been changed");
		con.close();
		return hasPasswordChanged;
	}


	//Cambia la password di un utente, se la password è stata cambiata con successo allora viene
	//restiuito il valore true, altrimenti false
	public static void createRepositoryForUser(int userID) throws Exception {

		Connection con = getConnection();
		PreparedStatement createRepositoryQuery = con.prepareStatement("INSERT INTO repository (OwnerID) VALUES (?)");
		createRepositoryQuery.setInt(1, userID);
		int affectedRecords = createRepositoryQuery.executeUpdate();
		if(affectedRecords>0) {
			System.out.println("Repository created");
		}
		con.close();
	}

////////////////////////////////////////////////////////////////////////////////////////////////////
////    INIZIO METODI PRIVATI    //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////

	//Metodo che dato in input un token, controlla se quel token è già presente nella tabella passwordrecovery
	private static Boolean isTokenInDatabase(String token) throws Exception{
		Connection con = getConnection();
		Boolean tokenIsInDatabase = false;

		PreparedStatement query1 = con.prepareStatement("SELECT UserID FROM passwordrecovery WHERE token=?");
		query1.setString(1, token);
		ResultSet result1 = query1.executeQuery();
		if(result1.next()) {
			tokenIsInDatabase=true;
		}
		con.close();
		return tokenIsInDatabase;
	}

	//Dato un id utente fa diventare usati tutti i token associati all'utente
	private static void setAllTokenOfUserAsUsed(int userId) throws Exception{
		Connection con = getConnection();
		//Used nella query è = 1 invece che TRUE perché MySQL non accetta tipi booleani e per simularli
		//nella tabella è stato usato il tipo "tinyInt" che può contenere solo i valori 0 e 1, quindi 0 corrisponde
		//per noi a FALSE e 1 a TRUE
		PreparedStatement usedTokenQuery = con.prepareStatement("UPDATE passwordrecovery SET Used=1 WHERE UserID=?");
		usedTokenQuery.setString(1, Integer.toString(userId));
		usedTokenQuery.executeUpdate();
		con.close();
	}
}