package database.user;

import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.dao.DaoManager;
import com.j256.ormlite.stmt.DeleteBuilder;
import com.j256.ormlite.stmt.PreparedQuery;
import com.j256.ormlite.stmt.QueryBuilder;
import com.j256.ormlite.stmt.UpdateBuilder;
import database.DatabaseHelper;
import java.time.Instant;

//Class to communicate with database with ORMLite
public class UserDao {
    private DatabaseHelper dbh = new DatabaseHelper();
    private Dao createUserDaoConnection(){
        try {
            return DaoManager.createDao(dbh.setupDatabaseConnection(),User.class);
        }catch (Exception e){
            System.out.println(e.getMessage());
            return null;
        }
    }

    public void addUser(User user)throws Exception {
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        userDao.create(user);
    }

    public boolean checkApprovedUser(String email) throws Exception {
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
        queryBuilder.where().eq("email",email);
        PreparedQuery<User> preparedQuery = queryBuilder.prepare();
        User user = userDao.queryForFirst(preparedQuery);
        return user.isApproved();
    }

    public boolean checkVerifiedUser(String email) throws Exception {
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
        queryBuilder.where().eq("email",email);
        PreparedQuery<User> preparedQuery = queryBuilder.prepare();
        User user = userDao.queryForFirst(preparedQuery);
        return user.isVerified();
    }

    public boolean updateUserPassword(String email, String password) throws Exception {
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        UpdateBuilder<User, String> updateBuilder = userDao.updateBuilder();
        updateBuilder.updateColumnValue("password",password);
        long now = Instant.now().toEpochMilli();
        updateBuilder.updateColumnValue("modification_date",now);
        updateBuilder.where().eq("email",email);
        updateBuilder.update();

        if(checkUserPassword(email, password)){
            return true;
        }else{
            return false;
        }
    }

    public void deleteUser(String email) throws Exception {
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        DeleteBuilder<User, String> deleteBuilder = userDao.deleteBuilder();
        deleteBuilder.where().eq("email",email);
        deleteBuilder.delete();
    }

    public boolean verifyUserExist(String email) throws Exception {
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
        queryBuilder.where().eq("email",email);
        PreparedQuery<User> preparedQuery = queryBuilder.prepare();
        User user = userDao.queryForFirst(preparedQuery);

        if(user==null){
            return false;
        }else{
            return true;
        }
    }

    public boolean checkUserPassword(String email, String password) throws Exception {
        User user = getUserWithEmail(email);
        if(password.equals(user.getPassword())){
            return true;
        }else{
            return false;
        }
    }

    public User getUserWithEmail(String email) throws Exception {
        Dao<User, String> userDao;
        if(!verifyUserExist(email)){
            return null;
        }else{
            userDao = createUserDaoConnection();
            QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
            queryBuilder.where().eq("email",email);
            PreparedQuery<User> preparedQuery = queryBuilder.prepare();
            return userDao.queryForFirst(preparedQuery);
        }
    }

    public User getUserWithPhone(String phone) throws Exception {
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
        queryBuilder.where().eq("phone",phone);
        PreparedQuery<User> preparedQuery = queryBuilder.prepare();
        return userDao.queryForFirst(preparedQuery);
    }

    public User getUserWithMailAndPhone(String email, String phone) throws Exception {
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
        queryBuilder.where().eq("email",email).and().eq("phone",phone);
        PreparedQuery<User> preparedQuery = queryBuilder.prepare();
        return userDao.queryForFirst(preparedQuery);
    }

    public User getUserWithHash(String userHash) throws Exception {
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        QueryBuilder<User,String> queryBuilder = userDao.queryBuilder();
        queryBuilder.where().eq("user_hash",userHash);
        PreparedQuery<User> preparedQuery = queryBuilder.prepare();
        return userDao.queryForFirst(preparedQuery);
    }

    public int getUserIdWithHashAndEmail(String userHash, String userEmail) throws Exception {
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        QueryBuilder<User,String> queryBuilder = userDao.queryBuilder();
        queryBuilder.where().eq("user_hash",userHash).and().eq("email",userEmail);
        PreparedQuery<User> preparedQuery = queryBuilder.prepare();
        User userResponse = userDao.queryForFirst(preparedQuery);
        return userResponse.getUserId();
    }

    public void approveUser (String email) throws Exception {
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        UpdateBuilder<User, String> updateBuilder = userDao.updateBuilder();
        updateBuilder.updateColumnValue("approved",true);
        long now = Instant.now().toEpochMilli();
        updateBuilder.updateColumnValue("modification_date",now);
        updateBuilder.where().eq("email",email);
        updateBuilder.update();
    }

    public void verifyUser (String email) throws Exception{
        Dao<User, String> userDao;
        userDao = createUserDaoConnection();
        UpdateBuilder<User, String> updateBuilder = userDao.updateBuilder();
        updateBuilder.updateColumnValue("verified",true);
        long now = Instant.now().toEpochMilli();
        updateBuilder.updateColumnValue("modification_date",now);
        updateBuilder.where().eq("email",email);
        updateBuilder.update();
    }
}