<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

class User extends DataMapper {

	public $table = "users";

    public function __construct()
    {
        parent::__construct();

		$this->load->config('auth');
		$this->load->helper('string');

		$this->_default_rounds 					= $this->config->item('default_rounds');
		$this->_random_rounds 					= $this->config->item('random_rounds');
		$this->_min_rounds 						= $this->config->item('min_rounds');
		$this->_max_rounds 						= $this->config->item('max_rounds');
		$this->_password_recovery_key_expire 	= $this->config->item('password_recovery_key_expire');

		if ($this->_random_rounds)
		{
			$rand = rand($this->_min_rounds,$this->_max_rounds);
			$rounds = array('rounds' => $rand);
		}
		else
		{
			$rounds = array('rounds' => $this->_default_rounds);
		}

		// Load Bcrypt
		$this->load->library('bcrypt', $rounds);
	}

	/**
	 * email_exists
	 *
	 * Checks if given email exists
	 *
	 * @param  string  $email
	 * @return bool
	 */
	 function email_exists($email)
	 {
	 	$this->where('email', $email)->get();

		if ($this->exists())
		{
			return TRUE;
		}
	 }

	/**
	 * check_password
	 *
	 * This function takes a password and validates it
	 * against an entry in the users table.
	 *
	 * @param  string  $password          The password the user provides
	 * @param  string  $hashed_password   The hashed password stored in the database
	 * @return bool
	 */
	 function check_password($password, $hashed_password)
	 {
	 	$CI =& get_instance();

	 	return $CI->bcrypt->verify($password, $hashed_password);
	 }

	/**
	 * change_password
	 *
	 * @param  int     $user_id
	 * @param  string  $password
	 * @return bool
	 */
	 function change_password($user_id, $password)
	 {
	 	$this->where('id', $user_id)->get();

		$this->password = self::_encrypt($password);

		if ($this->save())
		{
			return TRUE;
		}
	 }

	/**
	 * is_valid_activation_key
	 *
	 * @param  string  $key
	 * @return bool
	 */
	 function is_valid_activation_key($key)
	 {
	    $this->get_by_activation_key($key);

		if ($this->exists())
		{
			return TRUE;
		}
	 }

	 /**
	  * set_activation_key
	  *
	  * @param  int  $user_id
	  * @return bool
	  */
	  function set_activation_key($user_id)
	  {
	  	$this->where('id', $user_id);
		$this->activation_key = self::_generate_unique_str();

		if ($this->save())
		{
			return TRUE;
		}
	  }

	 /**
	  * is_activated
	  *
	  * @param  int  $user_id
	  * @return bool
	  */
	 function is_activated($user_id)
	 {
	 	$this->where('id', $user_id)->get();

		if ($this->activated)
		{
			return TRUE;
		}
	 }

	/**
	 * activate
	 *
	 * @param  string  $key
	 * @return bool
	 */
	 function activate($key)
	 {
	 	if (self::is_valid_activation_key($key))
		{
			$this->where('activation_key', $key)->get();

			$this->activated = TRUE;
			$this->activation_key = NULL; // Remove activation key

			if ($this->save())
			{
				return TRUE;
			}
		}
	 }

	/**
	 * is_valid_password_recovery_key
	 *
	 * @param  int    $user_id
	 * @param  string $key
	 * @return bool
	 */
	 function is_valid_password_recovery_key($user_id, $key)
	 {
	 	$this->where('id', $user_id);
		$this->where('recover_password_key', $key);
		$this->where('recover_password_key_requested >', time() - $this->_password_recovery_key_expire);
		$this->get();

		if ($this->exists())
		{
			return TRUE;
		}
	 }

	 /**
	  * set_password_recovery_key
	  *
	  * If the current recovery key isn't old enough
	  * only update when this function was last
	  * requested to prevent sabotage
	  *
	  * @param  string  $email
	  */
	 function set_password_recovery_key($email)
	 {
		$this->where('email', $email)->get();

		if ($this->recover_password_key_requested < time() - $this->_password_recovery_key_expire){
			$this->recover_password_key = self::_generate_unique_str();
			$this->recover_password_key_requested = time();
		}else{
			//$this->recover_password_key = $this->recover_password_key;
			$this->recover_password_key_requested = time();
		}

		if ($this->save())
		{
			return TRUE;
		}
	}

	/**
	 * reset_password
	 *
	 * @param  int     $user_id
	 * @param  string  $key
	 * @param  string  $password
	 * @return bool
	 */
	 function reset_password($user_id, $key, $password)
	 {
	 	if (self::is_valid_password_recovery_key($user_id, $key))
		{
			$this->password = self::_encrypt($password);
			$this->recover_password_key = NULL;
			$this->recover_password_key_requested = NULL;

			if ($this->save())
			{
				return TRUE;
			}
		}
	 }

	 /**
	  * login
	  *
	  * @param  string  $username
	  * @param  string  $password
	  * @return bool
	  */
	 function login($username, $password)
	 {
	 	$CI =& get_instance();

		$this->where('username', $username)->get();

		if ($this->exists() && self::check_password($password, $this->password))
		{
			$this->last_login 	= time();
			$this->save();

			return TRUE;
		}

	 }

	/**
	 * register
	 *
	 * @param  mixed  $data
	 * @param  bool   $require_activation
	 * @return bool
	 */
	function register($data, $require_activation)
	{
		$CI =& get_instance();

		$this->username 		= $data['username'];
		$this->password 		= self::_encrypt($data['password']);
		$this->email 	 		= $data['email'];
		$this->first_name 		= $data['first_name'];
		$this->last_name		= $data['last_name'];
		$this->activated		= $require_activation === TRUE ? FALSE : TRUE;
		$this->activation_key 	= $require_activation === TRUE ? self::_generate_unique_str() : NULL;
		$this->ip_address		= $this->_ip_address;
		$this->created_on		= time();

		if ($this->save())
		{
			return TRUE;
		}
	}

	/**
	 * _generate_unique_key
	 *
	 * Generates a unique string (32 chars in lenght)
	 *
	 * @return  string
	 */
	function _generate_unique_str()
	{
		return random_string('unique');
	}

	/**
	 * _encrypt
	 *
	 * @param string $password
	 */
	function _encrypt($password)
	{
	 	$CI =& get_instance();

		return $CI->bcrypt->hash($password);
	}
}