/**
 * poll page handler; allows the use of fancy URLs
 *
 * @param array $page From the page_handler function
 * @return true|false Depending on success
 */
function polls_page_handler($page)
{
    elgg_load_library('elgg:polls');
    $page_type = $page[0];
    switch ($page_type) {
        case "view":
            echo polls_get_page_view($page[1]);
            break;
        case "all":
            echo polls_get_page_list($page_type);
            break;
        case "add":
        case "edit":
            echo polls_get_page_edit($page_type, $page[1]);
            break;
        case "friends":
        case "owner":
            $username = $page[1];
            $user = get_user_by_username($username);
            $user_guid = $user->guid;
            echo polls_get_page_list($page_type, $user_guid);
            break;
        case "group":
            echo polls_get_page_list($page_type, $page[1]);
            break;
        default:
            return FALSE;
            break;
    }
    return TRUE;
}

/**
 * Gets the page owner for the current page.
 * @uses $CONFIG
 * @return int|false The current page owner guid (0 if none).
 */
function page_owner()
{
    global $CONFIG;
    $setpageowner = set_page_owner();
    if ($setpageowner !== false) {
        return $setpageowner;
    }
    if ($username = get_input("username")) {
        //if (substr_count($username,'group:')) {
        if (substr_count($username, 'group_')) {
            //preg_match('/group\:([0-9]+)/i',$username,$matches);
            preg_match('/group\\_([0-9]+)/i', $username, $matches);
            $guid = $matches[1];
            if ($entity = get_entity($guid)) {
                return $entity->getGUID();
            }
        }
        if ($user = get_user_by_username($username)) {
            return $user->getGUID();
        }
    }
    if ($owner = get_input("owner_guid")) {
        if ($user = get_entity($owner)) {
            return $user->getGUID();
        }
    }
    if (!empty($CONFIG->page_owner_handlers) && is_array($CONFIG->page_owner_handlers)) {
        foreach ($CONFIG->page_owner_handlers as $handler) {
            if ($guid = $handler()) {
                return $guid;
            }
        }
    }
    return 0;
}

 /**
  * This functions performs actions when a wire post is created
  *
  * @param string     $event  'create'
  * @param string     $type   'object'
  * @param \ElggObject $object the ElggObject created
  *
  * @return void
  */
 public static function triggerMentionNotificationEvent($event, $type, \ElggObject $object)
 {
     if (!elgg_instanceof($object, 'object', 'thewire')) {
         return;
     }
     // @todo replace with decent Elgg 2.0 notification event handling
     //send out notification to users mentioned in a wire post
     $usernames = [];
     preg_match_all("/\\@([A-Za-z0-9\\_\\.\\-]+)/i", $object->description, $usernames);
     if (empty($usernames)) {
         return;
     }
     $usernames = array_unique($usernames[0]);
     $params = ['object' => $object, 'action' => 'mention'];
     foreach ($usernames as $username) {
         $username = str_ireplace('@', '', $username);
         $user = get_user_by_username($username);
         if (empty($user) || $user->getGUID() == $object->getOwnerGUID()) {
             continue;
         }
         $setting = thewire_tools_get_notification_settings($user->getGUID());
         if (empty($setting)) {
             continue;
         }
         $subject = elgg_echo('thewire_tools:notify:mention:subject');
         $message = elgg_echo('thewire_tools:notify:mention:message', [$user->name, $object->getOwnerEntity()->name, elgg_normalize_url("thewire/search/@{$user->username}")]);
         notify_user($user->getGUID(), $object->getOwnerGUID(), $subject, $message, $params, $setting);
     }
 }

/**
 * Profile page handler
 *
 * @param array $page Array of URL segments passed by the page handling mechanism
 * @return bool
 */
function profile_page_handler($page)
{
    if (isset($page[0])) {
        $username = $page[0];
        $user = get_user_by_username($username);
        elgg_set_page_owner_guid($user->guid);
    } elseif (elgg_is_logged_in()) {
        forward(elgg_get_logged_in_user_entity()->getURL());
    }
    // short circuit if invalid or banned username
    if (!$user || $user->isBanned() && !elgg_is_admin_logged_in()) {
        register_error(elgg_echo('profile:notfound'));
        forward();
    }
    $action = NULL;
    if (isset($page[1])) {
        $action = $page[1];
    }
    if ($action == 'edit') {
        // use the core profile edit page
        $base_dir = elgg_get_root_path();
        require "{$base_dir}pages/profile/edit.php";
        return true;
    }
    $content = elgg_view('profile/layout', array('entity' => $user));
    $body = elgg_view_layout('one_column', array('content' => $content));
    echo elgg_view_page($user->name, $body);
    return true;
}

/**
 * Messageboard dispatcher for flat message board.
 * Profile (and eventually group) widgets handle their own.
 *
 * URLs take the form of
 *  User's messageboard:               messageboard/owner/<username>
 *  Y's history of posts on X's board: messageboard/owner/<X>/history/<Y>
 *  New post:                          messageboard/add/<guid> (container: user or group)
 *  Group messageboard:                messageboard/group/<guid>/all (not implemented)
 *
 * @param array $page Array of page elements
 * @return bool
 */
function messageboard_page_handler($page)
{
    $pages = dirname(__FILE__) . '/pages/messageboard';
    switch ($page[0]) {
        case 'owner':
            //@todo if they have the widget disabled, don't allow this.
            $owner_name = elgg_extract(1, $page);
            $owner = get_user_by_username($owner_name);
            set_input('page_owner_guid', $owner->guid);
            $history = elgg_extract(2, $page);
            $username = elgg_extract(3, $page);
            if ($history && $username) {
                set_input('history_username', $username);
            }
            include "{$pages}/owner.php";
            break;
        case 'add':
            $container_guid = elgg_extract(1, $page);
            set_input('container_guid', $container_guid);
            include "{$pages}/add.php";
            break;
        case 'group':
            elgg_group_gatekeeper();
            $owner_guid = elgg_extract(1, $page);
            set_input('page_owner_guid', $owner_guid);
            include "{$pages}/owner.php";
            break;
        default:
            return false;
    }
    return true;
}

function au_landing_router($hook, $type, $return, $params)
{
    if ($type == 'blog' && $return['segments'][0] == 'new') {
        $user = get_user_by_username($return['segments'][1]);
        if ($user) {
            system_message(elgg_echo('changebookmark'));
            forward(elgg_get_site_url() . 'blog/add/' . $user->guid);
            exit;
        }
        // must be a group
        $guid = str_replace('group:', '', $return['segments'][1]);
        $group = get_entity($guid);
        if (elgg_instanceof($group, 'group', '', 'ElggGroup')) {
            system_message(elgg_echo('changebookmark'));
            forward(elgg_get_site_url() . 'blog/add/' . $group->guid);
        }
        return FALSE;
    }
    // forward old groups urls to new group urls
    if ($type == 'groups' && is_numeric($return['segments'][0])) {
        $group = get_entity($return['segments'][0]);
        if ($group instanceof \ElggGroup) {
            system_message(elgg_echo('changebookmark'));
            forward($group->getURL());
        }
    }
}

/**
 * Profile page handler
 *
 * @param array $page Array of page elements, forwarded by the page handling mechanism
 */
function profile_page_handler($page)
{
    if (isset($page[0])) {
        $username = $page[0];
        $user = get_user_by_username($username);
        elgg_set_page_owner_guid($user->guid);
    }
    // short circuit if invalid or banned username
    if (!$user || $user->isBanned() && !elgg_is_admin_logged_in()) {
        register_error(elgg_echo('profile:notfound'));
        forward();
    }
    $action = NULL;
    if (isset($page[1])) {
        $action = $page[1];
    }
    if ($action == 'edit') {
        // use the core profile edit page
        $base_dir = elgg_get_root_path();
        require "{$base_dir}pages/profile/edit.php";
        return;
    }
    // main profile page
    $params = array('content' => elgg_view('profile/wrapper'), 'num_columns' => 3);
    $content = elgg_view_layout('widgets', $params);
    $body = elgg_view_layout('one_column', array('content' => $content));
    echo elgg_view_page($title, $body);
}

/**
 * Profile page handler
 *
 * @param array $page Array of URL segments passed by the page handling mechanism
 * @return bool
 */
function profile_page_handler($page)
{
    if (isset($page[0])) {
        $username = $page[0];
        $user = get_user_by_username($username);
        elgg_set_page_owner_guid($user->guid);
    } elseif (elgg_is_logged_in()) {
        forward(elgg_get_logged_in_user_entity()->getURL());
    }
    // short circuit if invalid or banned username
    if (!$user || $user->isBanned() && !elgg_is_admin_logged_in()) {
        register_error(elgg_echo('profile:notfound'));
        forward();
    }
    $action = NULL;
    if (isset($page[1])) {
        $action = $page[1];
    }
    if ($action == 'edit') {
        // use the core profile edit page
        echo elgg_view_resource('profile/edit');
        return true;
    }
    echo elgg_view_resource('profile/view', ['username' => $page[0]]);
    return true;
}

/**
 * Route page requests
 *
 * @param array $page Array of url parameters
 * @return bool
 */
function notifications_page_handler($page)
{
    gatekeeper();
    $current_user = elgg_get_logged_in_user_entity();
    // default to personal notifications
    if (!isset($page[0])) {
        $page[0] = 'personal';
    }
    if (!isset($page[1])) {
        forward("notifications/{$page[0]}/{$current_user->username}");
    }
    $user = get_user_by_username($page[1]);
    if ($user->guid != $current_user->guid && !$current_user->isAdmin()) {
        forward();
    }
    $base = elgg_get_plugins_path() . 'notifications';
    // note: $user passed in
    switch ($page[0]) {
        case 'group':
            require "{$base}/groups.php";
            break;
        case 'personal':
            require "{$base}/index.php";
            break;
        default:
            return false;
    }
    return true;
}

function monashees_profile_page_handler($page)
{
    if (isset($page[0])) {
        $username = $page[0];
        $user = get_user_by_username($username);
        elgg_set_page_owner_guid($user->guid);
    } elseif (elgg_is_logged_in()) {
        forward(elgg_get_logged_in_user_entity()->getURL());
    }
    // short circuit if invalid or banned username
    if (!$user || $user->isBanned() && !elgg_is_admin_logged_in()) {
        register_error(elgg_echo('profile:notfound'));
        forward();
    }
    $action = NULL;
    if (isset($page[1])) {
        $action = $page[1];
    }
    if ($action == 'edit') {
        // use the core profile edit page
        $base_dir = elgg_get_root_path();
        require "{$base_dir}pages/profile/edit.php";
        return true;
    }
    // main profile page
    /*$params = array (
              'content' => elgg_view ( 'profile/wrapper' ),
              'num_columns' => 3 
      );*/
    //$content = elgg_view_layout ( 'widgets', $params );
    $body = elgg_view_layout('two_sidebar', array('content' => elgg_view('profile/wrapper') . "" . elgg_view("profile/owner_block") . "" . elgg_view("profile/homeposts"), 'username' => $username));
    echo elgg_view_page($user->name, $body);
    return true;
}

/**
 * Messageboard dispatcher for flat message board.
 * Profile (and eventually group) widgets handle their own.
 *
 * URLs take the form of
 *  User's messageboard:               messageboard/owner/<username>
 *  Y's history of posts on X's board: messageboard/owner/<X>/history/<Y>
 *  New post:                          messageboard/add/<guid> (container: user or group)
 *  Group messageboard:                messageboard/group/<guid>/all (not implemented)
 *
 * @param array $page Array of page elements
 * @return bool
 */
function messageboard_page_handler($page)
{
    switch ($page[0]) {
        case 'owner':
            //@todo if they have the widget disabled, don't allow this.
            $owner_name = elgg_extract(1, $page);
            $owner = get_user_by_username($owner_name);
            set_input('page_owner_guid', $owner->guid);
            $history = elgg_extract(2, $page);
            $username = elgg_extract(3, $page);
            if ($history && $username) {
                set_input('history_username', $username);
            }
            echo elgg_view('resources/messageboard/owner');
            break;
        case 'add':
            $container_guid = elgg_extract(1, $page);
            set_input('container_guid', $container_guid);
            echo elgg_view('resources/messageboard/add');
            break;
        case 'group':
            elgg_group_gatekeeper();
            $owner_guid = elgg_extract(1, $page);
            set_input('page_owner_guid', $owner_guid);
            echo elgg_view('resources/messageboard/owner');
            break;
        default:
            return false;
    }
    return true;
}

/**
 * This functions performs actions when a wire post is created
 *
 * @param string     $event  'create'
 * @param string     $type   'object'
 * @param ElggObject $object the ElggObject created
 *
 * @return void
 */
function thewire_tools_create_object_event_handler($event, $type, ElggObject $object)
{
    if (empty($object) || !elgg_instanceof($object, "object", "thewire")) {
        return;
    }
    //send out notification to users mentioned in a wire post
    $usernames = array();
    preg_match_all("/\\@([A-Za-z0-9\\_\\.\\-]+)/i", $object->description, $usernames);
    if (empty($usernames)) {
        return;
    }
    $usernames = array_unique($usernames[0]);
    $params = array("object" => $object, "action" => "mention");
    foreach ($usernames as $username) {
        $username = str_ireplace("@", "", $username);
        $user = get_user_by_username($username);
        if (empty($user) || $user->getGUID() == $object->getOwnerGUID()) {
            continue;
        }
        $setting = thewire_tools_get_notification_settings($user->getGUID());
        if (empty($setting)) {
            continue;
        }
        $subject = elgg_echo("thewire_tools:notify:mention:subject");
        $message = elgg_echo("thewire_tools:notify:mention:message", array($user->name, $object->getOwnerEntity()->name, elgg_normalize_url("thewire/search/@" . $user->username)));
        notify_user($user->getGUID(), $object->getOwnerGUID(), $subject, $message, $params, $setting);
    }
}

 /**
  * Return user info
  *
  * Returns info about the given user needs to contain
  * at least these fields:
  *
  * name string  full name of the user
  * mail string  email addres of the user
  * grps array   list of groups the user is in
  *
  * @author  Andreas Gohr <[email protected]>
  */
 function getUserData($username)
 {
     $user = get_user_by_username($username);
     //error_log("getUserData:".$username);
     if (!$user) {
         return false;
     }
     //error_log("getUserData:".$username);
     $page_owner = elgg_get_page_owner_entity();
     $grps = array();
     if ($page_owner instanceof ElggGroup) {
         if ($page_owner->canEdit($user->getGUID())) {
             $grps[] = "admin";
             $grps[] = "root";
             //error_log('operator');
         } elseif ($page_owner->isMember($user)) {
             $grps[] = "member";
         }
     } elseif ($page_owner instanceof ElggUser) {
         if ($page_owner == $user) {
             $grps[] = "admin";
         } elseif ($page_owner->isFriendsWith($user->getGUID())) {
             $grps[] = "member";
         }
     }
     if ($user->isAdmin()) {
         $grps[] = "root";
         $grps[] = "admin";
     }
     $groups = elgg_get_entities_from_relationship(array('relationship' => 'member', 'relationship_guid' => $user->getGUID(), 'inverse_relationship' => FALSE, 'limit' => 0));
     foreach ($groups as $group) {
         $grps[] = $this->cleanUser($group->name);
     }
     return array('name' => $user->name, 'mail' => $user->email, 'grps' => $grps);
 }

/**
 * Stripe related pages
 *
 * @param array $page
 * @param string $handler
 * @return boolean
 */
function stripe_page_handler($page, $handler)
{
    gatekeeper();
    $username = elgg_extract(0, $page, false);
    if ($username) {
        $user = get_user_by_username($username);
    }
    if (!elgg_instanceof($user) || !$user->canEdit()) {
        $user = elgg_get_logged_in_user_entity();
        forward("{$handler}/{$user->username}");
    }
    elgg_set_context('settings');
    elgg_set_page_owner_guid($user->guid);
    elgg_push_breadcrumb(elgg_echo('stripe:billing'), 'billing');
    $context = elgg_extract(1, $page, 'cards');
    $action = elgg_extract(2, $page, 'all');
    $view = "stripe/pages/{$context}/{$action}";
    if (elgg_view_exists($view)) {
        $params = array('entity' => $user, 'id' => elgg_extract(3, $page, false), 'context' => $page);
        $title = elgg_echo("stripe:{$context}:{$action}");
        $content = elgg_view($view, $params);
        $sidebar = elgg_view('stripe/sidebar', $params);
        $filter = elgg_view("stripe/filters/{$context}/{$action}", $params);
    }
    if ($content) {
        if (elgg_is_xhr()) {
            echo $content;
        } else {
            $layout = elgg_view_layout('content', array('title' => $title, 'content' => $content, 'sidebar' => $sidebar, 'filter' => $filter));
            echo elgg_view_page($title, $layout);
        }
        return true;
    }
    return false;
}

 function show_members_json($context, $limit = 30, $offset = 0, $username)
 {
     if (!$username) {
         $user = elgg_get_logged_in_user_entity();
     } else {
         $user = get_user_by_username($username);
         if (!$user) {
             throw new InvalidParameterException('registration:usernamenotvalid');
         }
     }
     if ($context == "newest") {
         $params = array('types' => 'user', 'limit' => $limit, 'full_view' => FALSE);
         $latest_member = elgg_get_entities($params);
         //return $return;
     }
     if ($context == "online") {
         $latest_member = get_online_users();
     }
     if ($context == "popular") {
         $params = array('types' => 'user', 'relationship' => 'friend', 'inverse_relationship' => false);
         $latest_member = elgg_list_entities_from_relationship_count($params);
     }
     if ($latest_member) {
         foreach ($latest_member as $single) {
             $member['guid'] = $single->guid;
             $member['name'] = $single->name;
             //$member['avatar_url'] = get_entity_icon_url($single,'small');
             $return[] = $member;
         }
     }
     //return $return;
     return json_encode($return, true);
 }

/**
 * Messageboard dispatcher for flat message board.
 * Profile (and eventually group) widgets handle their own.
 *
 * URLs take the form of
 *  User's messageboard:               messageboard/owner/<username>
 *  Y's history of posts on X's board: messageboard/owner/<X>/history/<Y>
 *  New post:                          messageboard/add/<guid> (container: user or group)
 *  Group messageboard:                messageboard/group/<guid>/all (not implemented)
 *
 * @param array $page Array of page elements
 * @return bool
 */
function messageboard_page_handler($page)
{
    $vars = [];
    switch ($page[0]) {
        case 'owner':
            //@todo if they have the widget disabled, don't allow this.
            $owner_name = elgg_extract(1, $page);
            $owner = get_user_by_username($owner_name);
            $vars['page_owner_guid'] = $owner->guid;
            $history = elgg_extract(2, $page);
            $username = elgg_extract(3, $page);
            if ($history && $username) {
                $vars['history_username'] = $username;
            }
            echo elgg_view_resource('messageboard/owner', $vars);
            break;
        case 'group':
            elgg_group_gatekeeper();
            $owner_guid = elgg_extract(1, $page);
            $vars['page_owner_guid'] = $owner_guid;
            echo elgg_view_resource('messageboard/owner', $vars);
            break;
        default:
            return false;
    }
    return true;
}

 /**
  * Construct a new user entity
  *
  * Plugin developers should only use the constructor to create a new entity.
  * To retrieve entities, use get_entity() and the elgg_get_entities* functions.
  *
  * @param \stdClass $row Database row result. Default is null to create a new user.
  *
  * @throws IOException|InvalidParameterException if there was a problem creating the user.
  */
 public function __construct($row = null)
 {
     $this->initializeAttributes();
     if (!empty($row)) {
         // Is $row is a DB entity row
         if ($row instanceof \stdClass) {
             // Load the rest
             if (!$this->load($row)) {
                 $msg = "Failed to load new " . get_class() . " for GUID:" . $row->guid;
                 throw new \IOException($msg);
             }
         } else {
             if (is_string($row)) {
                 // $row is a username
                 elgg_deprecated_notice('Passing a username to constructor is deprecated. Use get_user_by_username()', 1.9);
                 $user = get_user_by_username($row);
                 if ($user) {
                     foreach ($user->attributes as $key => $value) {
                         $this->attributes[$key] = $value;
                     }
                 }
             } else {
                 if (is_numeric($row)) {
                     // $row is a GUID so load entity
                     elgg_deprecated_notice('Passing a GUID to constructor is deprecated. Use get_entity()', 1.9);
                     if (!$this->load($row)) {
                         throw new \IOException("Failed to load new " . get_class() . " from GUID:" . $row);
                     }
                 } else {
                     throw new \InvalidParameterException("Unrecognized value passed to constuctor.");
                 }
             }
         }
     }
 }

 /**
  * Listen to the blog page handler, to takeover some pages
  *
  * @param string $hook         "route"
  * @param string $type         "blog"
  * @param array  $return_value the current page_handler params
  * @param null   $params       null
  *
  * @return array|bool
  */
 public static function blog($hook, $type, $return_value, $params)
 {
     if (empty($return_value) || !is_array($return_value)) {
         // someone else had a route hook
         return $return_value;
     }
     $page = elgg_extract("segments", $return_value);
     if (empty($page)) {
         return $return_value;
     }
     $pages_path = elgg_get_plugins_path() . "blog_tools/pages/";
     switch ($page[0]) {
         case "owner":
             $user = get_user_by_username($page[1]);
             if (!empty($user)) {
                 $return_value = false;
                 // push all blogs breadcrumb
                 elgg_push_breadcrumb(elgg_echo("blog:blogs"), "blog/all");
                 set_input("owner_guid", $user->guid);
                 include $pages_path . "owner.php";
             }
             break;
         case "read":
             // Elgg 1.7 compatibility
         // Elgg 1.7 compatibility
         case "view":
             if (!elgg_is_logged_in()) {
                 $setting = elgg_get_plugin_setting("advanced_gatekeeper", "blog_tools");
                 if ($setting != "no") {
                     if (isset($page[1]) && !get_entity($page[1])) {
                         elgg_gatekeeper();
                     }
                 }
             }
             set_input("guid", $page[1]);
             // to be used in the blog_tools/full/related view
             break;
         case "add":
         case "edit":
             $return_value = false;
             // push all blogs breadcrumb
             elgg_push_breadcrumb(elgg_echo("blog:blogs"), "blog/all");
             set_input("page_type", $page[0]);
             if (isset($page[1])) {
                 set_input("guid", $page[1]);
             }
             if (isset($page[2])) {
                 set_input("revision", $page[2]);
             }
             include $pages_path . "edit.php";
             break;
         case "featured":
             $return_value = false;
             include $pages_path . "featured.php";
             break;
     }
     return $return_value;
 }

/**
 * Dispatcher for bookmarks.
 *
 * URLs take the form of
 *  All bookmarks:        bookmarks/all
 *  User's bookmarks:     bookmarks/owner/<username>
 *  Friends' bookmarks:   bookmarks/friends/<username>
 *  View bookmark:        bookmarks/view/<guid>/<title>
 *  New bookmark:         bookmarks/add/<guid> (container: user, group, parent)
 *  Edit bookmark:        bookmarks/edit/<guid>
 *  Group bookmarks:      bookmarks/group/<guid>/owner
 *  Bookmarklet:          bookmarks/bookmarklet/<guid> (user)
 *
 * Title is ignored
 *
 * @param array $page
 */
function bookmarks_page_handler($page)
{
    elgg_load_library('elgg:bookmarks');
    elgg_push_breadcrumb(elgg_echo('bookmarks'), 'bookmarks/all');
    elgg_push_context('bookmarks');
    // old group usernames
    if (substr_count($page[0], 'group:')) {
        preg_match('/group\\:([0-9]+)/i', $page[0], $matches);
        $guid = $matches[1];
        if ($entity = get_entity($guid)) {
            bookmarks_url_forwarder($page);
        }
    }
    // user usernames
    $user = get_user_by_username($page[0]);
    if ($user) {
        bookmarks_url_forwarder($page);
    }
    $pages = dirname(__FILE__) . '/pages/bookmarks';
    switch ($page[0]) {
        case "all":
            include "{$pages}/all.php";
            break;
        case "owner":
            include "{$pages}/owner.php";
            break;
        case "friends":
            include "{$pages}/friends.php";
            break;
        case "read":
        case "view":
            set_input('guid', $page[1]);
            include "{$pages}/view.php";
            break;
        case "add":
            gatekeeper();
            include "{$pages}/add.php";
            break;
        case "edit":
            gatekeeper();
            set_input('guid', $page[1]);
            include "{$pages}/edit.php";
            break;
        case 'group':
            group_gatekeeper();
            include "{$pages}/owner.php";
            break;
        case "bookmarklet":
            set_input('container_guid', $page[1]);
            include "{$pages}/bookmarklet.php";
            break;
        default:
            return false;
    }
    elgg_pop_context();
    return true;
}

/**
 * Can we allow the user with the credentials to log in?
 * Check stormpath, create the user if they can log in and don't exist
 * Enable the user if they can log in but were waiting for email verification
 * 
 * @param type $credentials
 * @return boolean
 */
function pam_handler($credentials)
{
    // try to authenticate first
    $application = get_application();
    $authResult = $application->authenticate($credentials['username'], $credentials['password']);
    $account = $authResult->account;
    if (!$account || strtolower($account->status) != 'enabled') {
        return false;
    }
    // we need to search hidden users too
    // in case of email confirmation disabling
    $show_hidden = access_get_show_hidden_status();
    access_show_hidden_entities(true);
    // we have an account and it's enabled
    // see if we have a matching account here
    // check if logging in with email address
    if (strpos($credentials['username'], '@') !== false) {
        $users = get_user_by_email($credentials['username']);
        $user = $users[0];
    } else {
        $user = get_user_by_username($credentials['username']);
    }
    // custom context gives us permission to do this
    elgg_push_context('stormpath_validate_user');
    // if we don't have a user we need to create one
    if (!$user) {
        $user = new \ElggUser();
        $user->username = preg_replace("/[^a-zA-Z0-9]/", "", $account->username);
        $user->email = $account->email;
        $user->name = $account->fullName;
        $user->access_id = ACCESS_PUBLIC;
        $user->salt = _elgg_generate_password_salt();
        $user->password = generate_user_password($user, $credentials['password']);
        $user->owner_guid = 0;
        // Users aren't owned by anyone, even if they are admin created.
        $user->container_guid = 0;
        // Users aren't contained by anyone, even if they are admin created.
        $user->language = get_current_language();
        $user->save();
        $user->__stormpath_user = $account->href;
        elgg_set_user_validation_status($user->guid, TRUE, 'stormpath');
        // Turn on email notifications by default
        set_user_notification_setting($user->getGUID(), 'email', true);
    }
    // see if we need to enable/verify the user
    if (!$user->isEnabled() && in_array($user->disable_reason, array('stormpath_new_user', 'uservalidationbyemail_new_user'))) {
        $user->enable();
        $user->__stormpath_user = $account->href;
        elgg_set_user_validation_status($user->guid, TRUE, 'stormpath');
    }
    elgg_pop_context();
    access_show_hidden_entities($show_hidden);
    if ($user && $user->isEnabled()) {
        return true;
    }
    return false;
}