/**
 * Create or update the extras table for a given object.
 * Call create_entity first.
 *
 * @param int    $guid        The guid of the entity you're creating (as obtained by create_entity)
 * @param string $title       The title of the object
 * @param string $description The object's description
 *
 * @return bool
 */
function create_object_entity($guid, $title, $description)
{
    global $CONFIG;
    $guid = (int) $guid;
    $title = sanitise_string($title);
    $description = sanitise_string($description);
    $row = get_entity_as_row($guid);
    if ($row) {
        // Core entities row exists and we have access to it
        $query = "SELECT guid from {$CONFIG->dbprefix}objects_entity where guid = {$guid}";
        if ($exists = get_data_row($query)) {
            $query = "UPDATE {$CONFIG->dbprefix}objects_entity\n\t\t\t\tset title='{$title}', description='{$description}' where guid={$guid}";
            $result = update_data($query);
            if ($result != false) {
                // Update succeeded, continue
                $entity = get_entity($guid);
                elgg_trigger_event('update', $entity->type, $entity);
                return $guid;
            }
        } else {
            // Update failed, attempt an insert.
            $query = "INSERT into {$CONFIG->dbprefix}objects_entity\n\t\t\t\t(guid, title, description) values ({$guid}, '{$title}','{$description}')";
            $result = insert_data($query);
            if ($result !== false) {
                $entity = get_entity($guid);
                if (elgg_trigger_event('create', $entity->type, $entity)) {
                    return $guid;
                } else {
                    $entity->delete();
                }
            }
        }
    }
    return false;
}

 public function __construct($guid = null)
 {
     if ($guid && !is_object($guid)) {
         $guid = get_entity_as_row($guid);
     }
     parent::__construct($guid);
 }

 /**
  * Check if an entity_guid is valid for sending tag notifications
  *
  * @param int $entity_guid the entity GUID
  *
  * @return bool
  */
 protected static function validateEntity($entity_guid)
 {
     $entity_guid = sanitize_int($entity_guid, false);
     if (empty($entity_guid)) {
         return false;
     }
     // cache plugin
     self::cachePlugin();
     if (check_entity_relationship(self::$plugin->getGUID(), 'tag_tools:notification', $entity_guid)) {
         // already enqueued
         return false;
     }
     // can't use elgg get entity because cache is not correctly updated
     $entity_row = get_entity_as_row($entity_guid);
     if ($entity_row === false) {
         // invalid entity
         return false;
     }
     $entity_access = sanitise_int($entity_row->access_id);
     if ($entity_access === ACCESS_PRIVATE) {
         // private entity
         return false;
     }
     if (!tag_tools_is_notification_entity($entity_guid)) {
         // not supported entity type/subtype
         return false;
     }
     return true;
 }

/**
 * Listen to the creation of metadata
 *
 * @param string       $event    the name of the event
 * @param string       $type     the type of the event
 * @param ElggMetadata $metadata supplied metadata
 *
 * @return void
 */
function tag_tools_create_metadata_event_handler($event, $type, $metadata)
{
    if (empty($metadata) || !$metadata instanceof ElggMetadata) {
        return;
    }
    // is it a tag
    if ($metadata->name != 'tags') {
        return;
    }
    // get the entity for further use
    $ia = elgg_set_ignore_access(true);
    $entity_guid = $metadata->entity_guid;
    // can't use elgg get entity because cache is not correctly updated
    $entity_row = get_entity_as_row($entity_guid);
    elgg_set_ignore_access($ia);
    // shortcut for private entities
    if ($entity_row->access_id == ACCESS_PRIVATE) {
        return;
    }
    // only send notifications on creation of the entity
    $time_created_treshold = 5;
    if ($entity_row->time_created < time() - $time_created_treshold) {
        // assume it is an update
        return;
    }
    // check of the entity is allowed for notifications
    if (!tag_tools_is_notification_entity($entity_row->guid)) {
        return;
    }
    $tag = $metadata->value;
    $options = ['type' => 'user', 'annotation_name_value_pairs' => ['name' => 'follow_tag', 'value' => $tag], 'limit' => false];
    $ia = elgg_set_ignore_access(true);
    $dbprefix = elgg_get_config('dbprefix');
    $entities = new ElggBatch('elgg_get_entities_from_annotations', $options);
    foreach ($entities as $user) {
        // check if not trying to notify the owner
        if ($user->getGUID() == $entity_row->owner_guid) {
            continue;
        }
        // force a correct access bit
        elgg_set_ignore_access(false);
        // check access for the user, can't use has_access_to_entity
        // because that requires a full entity
        $access_bit = _elgg_get_access_where_sql(['user_guid' => $user->getGUID()]);
        // ignore access to get the correct next user
        elgg_set_ignore_access(true);
        // build correct query to check access
        $query = "SELECT guid FROM {$dbprefix}entities e\n\t\t\t WHERE e.guid = {$entity_guid}\n\t\t\t AND {$access_bit}";
        if (get_data($query)) {
            // regsiter shutdown function because we need the full entity
            // this is a workaround and should be reviewed in the near future
            register_shutdown_function('tag_tools_notify_user', $user->getGUID(), $entity_row->guid, $tag);
        }
    }
    elgg_set_ignore_access($ia);
}

 /**
  * Class constructor
  *
  * @param integer  $guid The object guid
  * @param integer  $user_guid The users guid
  * @param string   $description The description (reason) for these points
  */
 public function __construct($guid = null, $user_guid = null, $description = null)
 {
     if ($guid && !is_object($guid)) {
         $guid = get_entity_as_row($guid);
     }
     parent::__construct($guid);
     if ($guid) {
         return true;
     }
     if (!($user = get_entity($user_guid))) {
         return false;
     }
     $this->attributes['owner_guid'] = $user_guid;
     $this->attributes['container_guid'] = $user_guid;
     $this->attributes['description'] = $description;
 }

/**
 * Create or update the entities table for a given group.
 * Call create_entity first.
 *
 * @param int    $guid        GUID
 * @param string $name        Name
 * @param string $description Description
 *
 * @return bool
 */
function create_group_entity($guid, $name, $description)
{
    global $CONFIG;
    $guid = (int) $guid;
    $name = sanitise_string($name);
    $description = sanitise_string($description);
    $row = get_entity_as_row($guid);
    if ($row) {
        // Exists and you have access to it
        $exists = get_data_row("SELECT guid from {$CONFIG->dbprefix}groups_entity WHERE guid = {$guid}");
        if ($exists) {
        } else {
        }
    }
    return false;
}

/**
 * Create or update the entities table for a given user.
 * Call create_entity first.
 *
 * @param int    $guid     The user's GUID
 * @param string $name     The user's display name
 * @param string $username The username
 * @param string $password The password
 * @param string $salt     A salt for the password
 * @param string $email    The user's email address
 * @param string $language The user's default language
 * @param string $code     A code
 *
 * @return bool
 */
function create_user_entity($guid, $name, $username, $password, $salt, $email, $language, $code)
{
    global $CONFIG;
    $guid = (int) $guid;
    $name = sanitise_string($name);
    $username = sanitise_string($username);
    $password = sanitise_string($password);
    $salt = sanitise_string($salt);
    $email = sanitise_string($email);
    $language = sanitise_string($language);
    $code = sanitise_string($code);
    $row = get_entity_as_row($guid);
    if ($row) {
        // Exists and you have access to it
        $query = "SELECT guid from {$CONFIG->dbprefix}users_entity where guid = {$guid}";
        if ($exists = get_data_row($query)) {
            $query = "UPDATE {$CONFIG->dbprefix}users_entity\n\t\t\t\tset name='{$name}', username='{$username}', password='{$password}', salt='{$salt}',\n\t\t\t\temail='{$email}', language='{$language}', code='{$code}', last_action = " . time() . " where guid = {$guid}";
            $result = update_data($query);
            if ($result != false) {
                // Update succeeded, continue
                $entity = get_entity($guid);
                if (elgg_trigger_event('update', $entity->type, $entity)) {
                    return $guid;
                } else {
                    $entity->delete();
                }
            }
        } else {
            // Update failed, attempt an insert.
            $query = "INSERT into {$CONFIG->dbprefix}users_entity\n\t\t\t\t(guid, name, username, password, salt, email, language, code)\n\t\t\t\tvalues ({$guid}, '{$name}', '{$username}', '{$password}', '{$salt}', '{$email}', '{$language}', '{$code}')";
            $result = insert_data($query);
            if ($result !== false) {
                $entity = get_entity($guid);
                if (elgg_trigger_event('create', $entity->type, $entity)) {
                    return $guid;
                } else {
                    $entity->delete();
                    //delete_entity($guid);
                }
            }
        }
    }
    return false;
}

/**
 * Create or update the entities table for a given site.
 * Call create_entity first.
 *
 * @param int    $guid        Site GUID
 * @param string $name        Site name
 * @param string $description Site Description
 * @param string $url         URL of the site
 *
 * @return bool
 * @access private
 */
function create_site_entity($guid, $name, $description, $url)
{
    global $CONFIG;
    $guid = (int) $guid;
    $name = sanitise_string($name);
    $description = sanitise_string($description);
    $url = sanitise_string($url);
    $row = get_entity_as_row($guid);
    if ($row) {
        // Exists and you have access to it
        $query = "SELECT guid from {$CONFIG->dbprefix}sites_entity where guid = {$guid}";
        if ($exists = get_data_row($query)) {
            $query = "UPDATE {$CONFIG->dbprefix}sites_entity\n\t\t\t\tset name='{$name}', description='{$description}', url='{$url}' where guid={$guid}";
            $result = update_data($query);
            if ($result != false) {
                // Update succeeded, continue
                $entity = get_entity($guid);
                if (elgg_trigger_event('update', $entity->type, $entity)) {
                    return $guid;
                } else {
                    $entity->delete();
                    //delete_entity($guid);
                }
            }
        } else {
            // Update failed, attempt an insert.
            $query = "INSERT into {$CONFIG->dbprefix}sites_entity\n\t\t\t\t(guid, name, description, url) values ({$guid}, '{$name}', '{$description}', '{$url}')";
            $result = insert_data($query);
            if ($result !== false) {
                $entity = get_entity($guid);
                if (elgg_trigger_event('create', $entity->type, $entity)) {
                    return $guid;
                } else {
                    $entity->delete();
                    //delete_entity($guid);
                }
            }
        }
    }
    return false;
}

/**
 * Create or update the entities table for a given user.
 * Call create_entity first.
 *
 * @param int    $guid     The user's GUID
 * @param string $name     The user's display name
 * @param string $username The username
 * @param string $password The password
 * @param string $salt     A salt for the password
 * @param string $email    The user's email address
 * @param string $language The user's default language
 * @param string $code     A code
 *
 * @return bool
 */
function create_user_entity($guid, $name, $username, $password, $salt, $email, $language, $code)
{
    global $CONFIG;
    $guid = (int) $guid;
    $name = sanitise_string($name);
    $username = sanitise_string($username);
    $password = sanitise_string($password);
    $salt = sanitise_string($salt);
    $email = sanitise_string($email);
    $language = sanitise_string($language);
    $code = sanitise_string($code);
    $row = get_entity_as_row($guid);
    if ($row) {
        // Exists and you have access to it
        $query = "SELECT guid from {$CONFIG->dbprefix}users_entity where guid = {$guid}";
        if ($exists = get_data_row($query)) {
        } else {
            // Exists query failed, attempt an insert.
        }
    }
    return false;
}

/**
 * Loads and returns an entity object from a guid.
 *
 * @param int $guid The GUID of the entity
 *
 * @return ElggEntity The correct Elgg or custom object based upon entity type and subtype
 */
function get_entity($guid)
{
    // This should not be a static local var. Notice that cache writing occurs in a completely
    // different instance outside this function.
    // @todo We need a single Memcache instance with a shared pool of namespace wrappers. This function would pull an instance from the pool.
    static $shared_cache;
    // We could also use: if (!(int) $guid) { return false },
    // but that evaluates to a false positive for $guid = true.
    // This is a bit slower, but more thorough.
    if (!is_numeric($guid) || $guid === 0 || $guid === '0') {
        return false;
    }
    // Check local cache first
    $new_entity = _elgg_retrieve_cached_entity($guid);
    if ($new_entity) {
        return $new_entity;
    }
    // Check shared memory cache, if available
    if (null === $shared_cache) {
        if (is_memcache_available()) {
            $shared_cache = new ElggMemcache('new_entity_cache');
        } else {
            $shared_cache = false;
        }
    }
    // until ACLs in memcache, DB query is required to determine access
    $entity_row = get_entity_as_row($guid);
    if (!$entity_row) {
        return false;
    }
    if ($shared_cache) {
        $cached_entity = $shared_cache->load($guid);
        // @todo store ACLs in memcache https://github.com/elgg/elgg/issues/3018#issuecomment-13662617
        if ($cached_entity) {
            // @todo use ACL and cached entity access_id to determine if user can see it
            return $cached_entity;
        }
    }
    // don't let incomplete entities cause fatal exceptions
    try {
        $new_entity = entity_row_to_elggstar($entity_row);
    } catch (IncompleteEntityException $e) {
        return false;
    }
    if ($new_entity) {
        _elgg_cache_entity($new_entity);
    }
    return $new_entity;
}

/**
 * Loads and returns an entity object from a guid.
 *
 * @param int $guid The GUID of the entity
 *
 * @return ElggEntity The correct Elgg or custom object based upon entity type and subtype
 * @link http://docs.elgg.org/DataModel/Entities
 */
function get_entity($guid)
{
    static $newentity_cache;
    $new_entity = false;
    // We could also use: if (!(int) $guid) { return FALSE },
    // but that evaluates to a false positive for $guid = TRUE.
    // This is a bit slower, but more thorough.
    if (!is_numeric($guid) || $guid === 0 || $guid === '0') {
        return FALSE;
    }
    if (!$newentity_cache && is_memcache_available()) {
        $newentity_cache = new ElggMemcache('new_entity_cache');
    }
    if ($newentity_cache) {
        $new_entity = $newentity_cache->load($guid);
    }
    if ($new_entity) {
        return $new_entity;
    }
    return entity_row_to_elggstar(get_entity_as_row($guid));
}

 /**
  * Loads attributes from the entities table into the object.
  *
  * @param int $guid GUID of Entity
  *
  * @return bool
  */
 protected function load($guid)
 {
     $row = get_entity_as_row($guid);
     if ($row) {
         // Create the array if necessary - all subclasses should test before creating
         if (!is_array($this->attributes)) {
             $this->attributes = array();
         }
         // Now put these into the attributes array as core values
         $objarray = (array) $row;
         foreach ($objarray as $key => $value) {
             $this->attributes[$key] = $value;
         }
         // Increment the portion counter
         if (!$this->isFullyLoaded()) {
             $this->attributes['tables_loaded']++;
         }
         // Cache object handle
         if ($this->attributes['guid']) {
             cache_entity($this);
         }
         return true;
     }
     return false;
 }

/**
 * Create metadata on the correct site
 *
 * @param string $hook
 * @param string $type
 * @param int $returnvalue
 * @param mixed $params
 * @return int $site_guid
 */
function subsite_manager_create_metadata_hook($hook, $type, $returnvalue, $params)
{
    $result = $returnvalue;
    $entity_guid = elgg_extract("entity_guid", $params);
    $metadata_name = elgg_extract("metadata_name", $params);
    $site_guid = elgg_extract("site_guid", $params);
    if (!empty($entity_guid)) {
        if ($entity_row = get_entity_as_row($entity_guid)) {
            if ($entity_row->type != "user") {
                // default set metadata to the site of the entity
                $result = (int) $entity_row->site_guid;
            } elseif (subsite_manager_on_subsite()) {
                global $SUBSITE_MANAGER_MAIN_PROFILE_FIELDS;
                $global_metadata_fields = array("validated", "validation_method", "validated_official", "icontime", "x1", "x2", "y1", "y2");
                if (!empty($SUBSITE_MANAGER_MAIN_PROFILE_FIELDS) && is_array($SUBSITE_MANAGER_MAIN_PROFILE_FIELDS)) {
                    $global_metadata_fields = array_merge($global_metadata_fields, array_keys($SUBSITE_MANAGER_MAIN_PROFILE_FIELDS));
                }
                if (in_array($metadata_name, $global_metadata_fields)) {
                    $result = elgg_get_site_entity()->getOwnerGUID();
                }
            }
        }
    }
    return $result;
}

/**
 * Check is notifications for this entity are allowed
 *
 * @param int $entity_guid the entity guid
 *
 * @return bool
 */
function tag_tools_is_notification_entity($entity_guid)
{
    $entity_guid = sanitise_int($entity_guid);
    $entity_row = get_entity_as_row($entity_guid);
    if (empty($entity_row)) {
        return false;
    }
    $type_subtypes = tag_tools_get_notification_type_subtypes();
    if (empty($type_subtypes) || !is_array($type_subtypes)) {
        return false;
    }
    $type = $entity_row->type;
    if (empty($type) || !isset($type_subtypes[$type])) {
        return false;
    }
    $subtype = get_subtype_from_id($entity_row->subtype);
    if (empty($subtype)) {
        // user, group, site
        return true;
    }
    return in_array($subtype, elgg_extract($type, $type_subtypes));
}

 /**
  * Loads attributes from the entities table into the object.
  *
  * @param mixed $guid GUID of entity or stdClass object from entities table
  *
  * @return bool
  */
 protected function load($guid)
 {
     if ($guid instanceof stdClass) {
         $row = $guid;
     } else {
         $row = get_entity_as_row($guid);
     }
     if ($row) {
         // Create the array if necessary - all subclasses should test before creating
         if (!is_array($this->attributes)) {
             $this->attributes = array();
         }
         // Now put these into the attributes array as core values
         $objarray = (array) $row;
         foreach ($objarray as $key => $value) {
             $this->attributes[$key] = $value;
         }
         // Increment the portion counter
         if (!$this->isFullyLoaded()) {
             $this->attributes['tables_loaded']++;
         }
         // guid needs to be an int  http://trac.elgg.org/ticket/4111
         $this->attributes['guid'] = (int) $this->attributes['guid'];
         // Cache object handle
         if ($this->attributes['guid']) {
             cache_entity($this);
         }
         return true;
     }
     return false;
 }

/**
 * Deletes all private settings for an entity.
 *
 * @param int $entity_guid The Entity GUID
 *
 * @return bool
 * @see get_private_setting()
 * @see get_all_private_settings()
 * @see set_private_setting()
 * @see remove_private_settings()
 * @link http://docs.elgg.org/DataModel/Entities/PrivateSettings
 */
function remove_all_private_settings($entity_guid)
{
    global $PRIVATE_SETTINGS_CACHE;
    static $private_setting_memcache;
    $dbprefix = elgg_get_config("dbprefix");
    $entity_guid = (int) $entity_guid;
    // check if you have access to the entity
    if (!get_entity_as_row($entity_guid)) {
        return false;
    }
    if (!isset($private_setting_memcache) && is_memcache_available()) {
        $private_setting_memcache = new ElggMemcache("private_settings");
    }
    $query = "DELETE FROM {$dbprefix}private_settings";
    $query .= " WHERE entity_guid = {$entity_guid}";
    $result = delete_data($query);
    if ($result !== false) {
        // unset local cache
        if (isset($PRIVATE_SETTINGS_CACHE[$entity_guid])) {
            unset($PRIVATE_SETTINGS_CACHE[$entity_guid]);
        }
        // unset memcache
        if ($private_setting_memcache) {
            // invalidate the settings in Memcache
            $private_setting_memcache->delete($entity_guid);
        }
    }
    return $result !== false;
}

/**
 * Loads and returns an entity object from a guid.
 *
 * @param int $guid The GUID of the entity
 *
 * @return ElggEntity The correct Elgg or custom object based upon entity type and subtype
 * @link http://docs.elgg.org/DataModel/Entities
 */
function get_entity($guid)
{
    static $newentity_cache;
    $new_entity = false;
    if (!is_numeric($guid)) {
        return FALSE;
    }
    if (!$newentity_cache && is_memcache_available()) {
        $newentity_cache = new ElggMemcache('new_entity_cache');
    }
    if ($newentity_cache) {
        $new_entity = $newentity_cache->load($guid);
    }
    if ($new_entity) {
        return $new_entity;
    }
    return entity_row_to_elggstar(get_entity_as_row($guid));
}

 /**
  * Overridden from ElggEntity and ElggObject::load(). Core always inits plugins with
  * a query joined to the objects_entity table, so all the info is there.
  *
  * @param mixed $guid GUID of an ElggObject or the stdClass object from entities table
  *
  * @return bool
  * @throws InvalidClassException
  */
 protected function load($guid)
 {
     $expected_attributes = $this->attributes;
     unset($expected_attributes['tables_split']);
     unset($expected_attributes['tables_loaded']);
     // this was loaded with a full join
     $needs_loaded = false;
     if ($guid instanceof stdClass) {
         $row = (array) $guid;
         $missing_attributes = array_diff_key($expected_attributes, $row);
         if ($missing_attributes) {
             $needs_loaded = true;
             $old_guid = $guid;
             $guid = $row['guid'];
         } else {
             $this->attributes = $row;
         }
     } else {
         $needs_loaded = true;
     }
     if ($needs_loaded) {
         $entity = (array) get_entity_as_row($guid);
         $object = (array) get_object_entity_as_row($guid);
         if (!$entity || !$object) {
             return false;
         }
         $this->attributes = array_merge($this->attributes, $entity, $object);
     }
     $this->attributes['tables_loaded'] = 2;
     // Check the type
     if ($this->attributes['type'] != 'object') {
         $msg = elgg_echo('InvalidClassException:NotValidElggStar', array($guid, get_class()));
         throw new InvalidClassException($msg);
     }
     // guid needs to be an int  http://trac.elgg.org/ticket/4111
     $this->attributes['guid'] = (int) $this->attributes['guid'];
     // cache the entity
     if ($this->attributes['guid']) {
         cache_entity($this);
     }
     return true;
 }

 /**
  * Loads attributes from the entities table into the object.
  *
  * @param mixed $guid GUID of entity or \stdClass object from entities table
  *
  * @return bool
  */
 protected function load($guid)
 {
     if ($guid instanceof \stdClass) {
         $row = $guid;
     } else {
         $row = get_entity_as_row($guid);
     }
     if ($row) {
         // Create the array if necessary - all subclasses should test before creating
         if (!is_array($this->attributes)) {
             $this->attributes = array();
         }
         // Now put these into the attributes array as core values
         $objarray = (array) $row;
         foreach ($objarray as $key => $value) {
             $this->attributes[$key] = $value;
         }
         // guid needs to be an int  https://github.com/elgg/elgg/issues/4111
         $this->attributes['guid'] = (int) $this->attributes['guid'];
         // for BC with 1.8, ->subtype always returns ID, ->getSubtype() the string
         $this->attributes['subtype'] = (int) $this->attributes['subtype'];
         // Cache object handle
         if ($this->attributes['guid']) {
             _elgg_services()->entityCache->set($this);
         }
         return true;
     }
     return false;
 }

/**
 * Create or update the extras table for a given group.
 * Call create_entity first.
 * 
 * @param int $guid
 * @param string $name
 * @param string $description
 */
function create_group_entity($guid, $name, $description)
{
    global $CONFIG;
    $guid = (int) $guid;
    $name = sanitise_string($name);
    $description = sanitise_string($description);
    $row = get_entity_as_row($guid);
    if ($row) {
        // Exists and you have access to it
        if ($exists = get_data_row("SELECT guid from {$CONFIG->dbprefix}groups_entity WHERE guid = {$guid}")) {
            $result = update_data("UPDATE {$CONFIG->dbprefix}groups_entity set name='{$name}', description='{$description}' where guid={$guid}");
            if ($result != false) {
                // Update succeeded, continue
                $entity = get_entity($guid);
                if (trigger_elgg_event('update', $entity->type, $entity)) {
                    return $guid;
                } else {
                    $entity->delete();
                    //delete_entity($guid);
                }
            }
        } else {
            // Update failed, attempt an insert.
            $result = insert_data("INSERT into {$CONFIG->dbprefix}groups_entity (guid, name, description) values ({$guid}, '{$name}','{$description}')");
            if ($result !== false) {
                $entity = get_entity($guid);
                if (trigger_elgg_event('create', $entity->type, $entity)) {
                    return $guid;
                } else {
                    $entity->delete();
                    //delete_entity($guid);
                }
            }
        }
    }
    return false;
}