<?php
class User_Model_Mapper_User extends Qliff_Model_Mapper_Db
{
    /**
     *
     * @var Qliff_Event_Observable
     */
    protected $_observable;
    protected $_messages = array();

    protected static $_users = array();
    protected static $_userRoles = array();
    protected static $_userInvitee = array();

    public function init() {
        $this->_observable = new User_Model_Observer_ObservableUser('user_permissions');
        $this->_observable->setMapper($this);
        $this->_observable->attach(new User_Model_Observer_Access());
        $this->_message = Zend_Registry::get('messages');
    }

    public function setDefaultTable() {
        $this->setDbTable(new User_Model_DbTable_Users());
    }

    /**
     * Login user to the system and start user session
     *
     * @param string $email
     * @param string $password
     * @return User_Model_User
     * @throws User_Model_Exception
     */
    public function login($email, $password, $hashed = false, $loadFromSession = true) {
        if (Zend_Auth::getInstance()->hasIdentity() && $loadFromSession) {
            //Get user data from session
            return Zend_Auth::getInstance()->getStorage()->read();
        }

        $adapter = new Zend_Auth_Adapter_DbTable(
                        $this->getDbTable()->getAdapter(),
                        'users',
                        'email', 'password', $hashed ? null :'MD5(?)'
        );

        $adapter->setIdentity($email)
                ->setCredential($password);

        $result = Zend_Auth::getInstance()->authenticate($adapter);

        if (!$result->isValid()) {
            throw new User_Model_Exception($this->_message['user_login_invalid']);
        }

        $user = $this->fetchByEmail(Zend_Auth::getInstance()->getIdentity(), new User_Model_User());

        if ($user->status == 0) {
            //If user is blocked (status == 0)
            Zend_Auth::getInstance()->clearIdentity();
            throw new User_Model_Exception(sprintf($this->_message['user_blocked'], $email));
        }

        //Update last login timestamp
        $user->setTimestampLogin(time());

        $user = $this->save($user);

        Zend_Auth::getInstance()->getStorage()->write($user);

        $userId = $user->getId();
        $userName = $user->getName();
        Zend_Registry::get('logger')->info("User: $userName <$userId>. Session started");
        return $user;
    }

    public function addRule($rule, Qliff_Model_ModelAbstract $model, $type, User_Model_Model $user) {
        $db = $this->getDbTable()->getAdapter();
        $db->insert('collaborate_rules', array(
            'entry_id' => $model->getId(),
            'entry_type' => $type,
            'user_id' => $user->getId(),
            'rule' => $rule
        ));
    }

    public function hasRule(Qliff_Model_ModelAbstract $model, $type, User_Model_Model $user) {
        $db = $this->getDbTable()->getAdapter();
        $entryId = (int)$model->getId();
        $userId = (int)$user->getId();
        $result = $db->fetchRow('collaborate_rules', "entry_id=$entryId AND entry_type=$type AND user_id=$userId");
        if ($result) {
            return $result->rule;
        }

        return false;
    }

    /**
     *
     * @param User_Model_User $user
     * @return array
     */
    public function getInviterRules(User_Model_User $user) {
        $invitees = $this->getUsersInvitedBy($user);
        $inviteeList = array();

        foreach($invitees as $invitee) {
            $inviteeList[] = $invitee['user']->getId();
        }

        $result = array();
        if (!empty($inviteeList)) {
            $select = $this->getDbTable()->getAdapter()->select()->from(array('cr' => 'collaborate_rules'))
                ->where('cr.user_id IN ('.implode(',', $inviteeList).')');

            $rules = $select->query()->fetchAll(Zend_Db::INT_TYPE);
            if ($rules) {
                $result = $rules;
            }
        }

        return $result;
    }

    /**
     * Be careful to use this function. Very expensive
     *
     * @param User_Model_User $user
     * @return array
     */
    public function getUsersInvitedBy(User_Model_User $user) {
        $id = (int)$user->getId();
        if (isset(self::$_userInvitee[$id])) {
            return self::$_userInvitee[$id];
        }

        $email = (string)$user->getEmail();
        $select = $this->getDbTable()->getAdapter()->select()->from(array('u' => 'users'))
                ->join(array('i' => 'invites'), 'u.email=i.email', array())
                ->where("i.user_id = $id AND i.email <> '$email'")
                ->distinct(true);

        $result = $select->query()->fetchAll();

        $folderMapper = new Views_Model_Mapper_Folders();

        $users = array();
        foreach($result as $row) {
            $user = new User_Model_User();
            $user->setId($row['id']);
            $user->setEmail($row['email'])
                    ->setName($row['username'])
                    ->setFirstName($row['first_name'])
                    ->setLastName($row['last_name'])
                    ->setTimestampReg($row['timestamp_reg'])
                    ->setTimestampLogin($row['timestamp_login'])
                    ->setCountry($row['country'])
                    ->setStatus($row['status'])
                    ->setPassword($row['password'])
                    ->setActivationCode($row['activation_code'])
                    ->setNotify($row['notify']);
            $this->initPermissions($user);
            $users[$row['id']]['user'] = $user;
            $users[$row['id']]['docs'] = array();
            $users[$row['id']]['docs']['folders'] = $users[$row['id']]['docs']['discussions']
                = $users[$row['id']]['docs']['files'] = array();

            $userRoot = $folderMapper->userRoot($user);

            foreach($userRoot->getFolders() as $folder) {
                if ($folder->getOwner()->getId() != $id) {
                    continue;
                }

                $users[$row['id']]['docs']['folders'][$folder->getId()] = $folder;
            }

            foreach($userRoot->getDiscussions() as $discussion) {
                if ($discussion->getOwner()->getId() != $id) {
                    continue;
                }

                $users[$row['id']]['docs']['discussions'][$discussion->getId()] = $discussion;
            }

            foreach($userRoot->getFiles() as $file) {
                if ($file->getOwner()->getId() != $id) {
                    continue;
                }

                $users[$row['id']]['docs']['files'][$file->getId()] = $file;
            }
        }

        self::$_userInvitee[$id] = $users;
        return $users;
    }

    public function updateInvitees($action, array $data) {
        $validData = array();

        foreach($data as $userId => $userData) {
            foreach($userData as $type => $docData) {
                foreach($docData as $docId => $checked) {
                    if ($checked == '1') {
                        $validData[] = array(
                            'entry_id' => $docId,
                            'entry_type' => $type,
                            'user_id' => $userId,
                            'rule' => null
                        );
                    }
                }
            }
        }

        switch ($action) {
            case 'remove':
                $users = array();
                foreach($validData as $record) {
                    if (!in_array($record['user_id'], $users)) {
                        $user = $this->fetch($record['user_id'], new User_Model_User());
                        $users[$record['user_id']] = $user;
                    }
                    $user = $users[$record['user_id']];
                    $model = Views_Model_Mapper_Factory::factoryModel(
                                $record['entry_id'],
                                $record['entry_type'],
                                $user
                            );
                    $this->unsubscribe($model, $record['entry_type'], $user);
                }
            case 'allow':
                foreach($validData as $record) {
                    $entryId = $record['entry_id'];
                    $entryType = $record['entry_type'];
                    $userId = $record['user_id'];
                    $this->getDbTable()->getAdapter()->delete('collaborate_rules',
                            "entry_id=$entryId AND entry_type='$entryType' AND user_id=$userId");
                }
                break;
            case 'deny':
                $rule = 'deny see owner document';
                foreach($validData as $record) {
                    $entryId = $record['entry_id'];
                    $entryType = $record['entry_type'];
                    $userId = $record['user_id'];
                    $this->getDbTable()->getAdapter()->delete('collaborate_rules',
                            "entry_id=$entryId AND entry_type='$entryType' AND user_id=$userId");
                    $record['rule'] = $rule;
                    $this->getDbTable()->getAdapter()->insert('collaborate_rules', $record);
                }
                break;
            default:
                break;
        }
    }

    /**
     *
     * @param mixed $where
     * @param mixed $order
     * @return array
     */
    public function getActionList($where = null, $order = null) {
        $select = $this->getDbTable()->getAdapter()->select()->from('action_list')
                ->order($order);
        if ($where) {
            $select->where($where);
        }

        $result = $select->query()->fetchAll(Zend_Db::FETCH_ASSOC);

        $items = array();
        foreach($result as $row) {
            $items[] = $row['action'];
        }

        return $items;
    }

    public function getRoles($where = null, $order = null) {
        $select = $this->getDbTable()->getAdapter()->select()->from('roles')
                ->order($order);
        if ($where) {
            $select->where($where);
        }

        $result = $select->query()->fetchAll(Zend_Db::FETCH_ASSOC);

        $items = array();
        foreach($result as $row) {
            $items[$row['id']] = array(
                'id' => $row['id'],
                'role' => $row['role']
            );

            if ($row['perm']) {
                $items[$row['id']]['perm'] = explode(',', $row['perm']);
            }
        }

        return $items;
    }

    public function updateRolePermissions($roleId, array $roleData) {
        $roleId = (int)$roleId;
        $actions = array_keys($roleData, '1');
        if ($actions) {
            $perm = implode(',', $actions);
        } else {
            $perm = '';
        }

        $select = $this->getDbTable()->getAdapter()->select()->from('user_roles')
                ->where("role_id=$roleId");

        $result = $select->query()->fetchAll(Zend_Db::FETCH_ASSOC);

        $userIds = array();
        foreach($result as $row) {
            $userIds[] = $row['user_id'];
        }

        if (!empty($userIds)) {
            $this->getDbTable()->update(array('rebuild' => 1), "id IN (" . implode(', ', $userIds) .")");
        }

        $this->getDbTable()->getAdapter()->update('roles', array('perm' => $perm), "id=$roleId");
    }

    protected function _getActionPermissionsByRole($roleId) {
        if (empty(self::$_userRoles)) {
            $select = $this->getDbTable()->getAdapter()->select()->from('roles', array('id', 'perm'));
            $result = $select->query()->fetchAll(Zend_Db::FETCH_ASSOC);

            foreach($result as $row) {
                if (!empty($row['perm'])) {
                    self::$_userRoles[$row['id']] = explode(',', $row['perm']);
                }
            }
        }

        return isset(self::$_userRoles[$roleId]) ? self::$_userRoles[$roleId] : array();
    }

    public function actionUsers($action, $userIds) {
        if (empty($userIds)) {
            return;
        }
        switch($action) {
            case 'activate':
                $this->activateUsers($userIds);
                break;
            case 'block':
                $this->blockUsers($userIds);
                break;
            case 'delete':
                $this->deleteUsers($userIds);
                break;
            default:
                throw new InvalidArgumentException("Invalid action: $action was provided");
        }
    }

    public function activateUsers($userIds) {
        $this->getDbTable()->update(array('status' => 1), "id IN (" . implode(', ', $userIds) . ')');
    }

    public function blockUsers($userIds) {
        $this->getDbTable()->update(array('status' => 0), "id IN (" . implode(', ', $userIds) . ')');
    }

    public function deleteUsers($userIds) {
        foreach($userIds as $userId) {
            $this->removeUser($userId);
        }

        //TODO remove all documents, permissions tied with these users
    }

    /**
     *
     * @param string $where
     * @param mixed $order
     * @param int $count
     * @param int $offset
     * @return array
     */
    public function getUsers($where = null, $order = null) {
        $db = $this->getDbTable()->getAdapter();

        $select = $db->select()->from(array('u' => 'users'))
                ->join(array('ur' => 'user_roles'), 'u.id=ur.user_id', array('role_id'))
                ->order($order);

        if ($where) {
            $select->where($where);
        }

        $result = $select->query()->fetchAll(Zend_Db::FETCH_ASSOC);
        if (!$result) {
            return array();
        }

        $users = array();

        foreach($result as $row) {
            $id = $row['id'];
            if (isset($users[$id])) {
                $users[$id]->addRole($row['role_id']);
                $users[$id]->setActionPermissions($this->_getActionPermissionsByRole($row['role_id']));
            } else {
                $user = new User_Model_User();
                $user->setId($id);
                $user->addRole($row['role_id']);
                $user->setEmail($row['email'])
                     ->setName($row['username'])
                     ->setFirstName($row['first_name'])
                     ->setLastName($row['last_name'])
                     ->setTimestampReg($row['timestamp_reg'])
                     ->setTimestampLogin($row['timestamp_login'])
                     ->setCountry($row['country'])
                     ->setStatus($row['status'])
                     ->setPassword($row['password'])
                     ->setActivationCode($row['activation_code'])
                     ->setNotify($row['notify']);
                $user->setActionPermissions($this->_getActionPermissionsByRole($row['role_id']));
                $users[$id] = $user;
            }
        }

        return $users;
    }

    public function getUserFileCount(User_Model_User $user) {
        $id = $this->getDbTable()->getAdapter()->quote($user->getId(), Zend_Db::INT_TYPE);

        $db = $this->getDbTable()->getAdapter();

        $select = $db->select()->from(
                    array('f' => 'files'),
                    array('file_count' => new Zend_Db_Expr("COUNT(*)")))
                ->where("user_id = $id");

        $result = $select->query()->fetch();
        return $result['file_count'];
    }

    public function getStorageSize(User_Model_User $user) {
        $id = $this->getDbTable()->getAdapter()->quote($user->getId(), Zend_Db::INT_TYPE);

        $db = $this->getDbTable()->getAdapter();

        $select = $db->select()->from(
                    array('f' => 'files'),
                    array('total_size' => new Zend_Db_Expr("SUM(size)")))
                ->where("user_id = $id");

        $result = $select->query()->fetch();
        return $result['total_size'];
    }

    /**
     * Set new password for user and send email notification with new data
     * @param string $email
     */
    public function forget($email) {
        $user = $this->fetchByEmail($email, new User_Model_User());
        if (!$user) {
            throw new Zend_Exception($this->_messages['user_doesnt_exist']);
        } else {
            $newPassword = substr(md5(time() . srand() . 'salT'), 0, 8);

            $user->setPassword($newPassword, false);
            $this->save($user);
            User_Model_Mail::forget($email, $newPassword);
            $userId = $user->getId();
            Zend_Registry::get('logger')->info("User: $userId. New password requested");
        }
    }

    /**
     * Register user in the system
     * @param array $data
     * @return User_Model_User
     */
    public function register(array $data) {
        $user = new User_Model_User();
        $user->setEmail($data['email'])
             ->setName($data['username'])
             ->setFirstName($data['firstname'])
             ->setLastName($data['lastname'])
             ->setTimestampReg(time())
             ->setTimestampLogin(0)
             ->setCountry(0)
             ->setStatus(0) //blocked
             ->setPassword($data['password'], false) //false to make md5
             ->setActivationCode($this->_generateActivationCode($data['email']))
             ->setNotify(1)
             ->addRole(2); //authenticated user

        $db = $this->getDbTable()->getAdapter();
        $email = $db->quote($data['email']);
        $select = $db->select()->from(array('i' => 'invites'))
               ->where("email=$email")
               ->where("accepted=0");

        $result = $select->query()->fetchAll();

        if ($result) {
            $user->addRole(User_Model_User::ROLE_INVITEE); //Invitee role
        } else {
            $user->addRole(User_Model_User::ROLE_FULL_USER); //Full user role
        }

        $user = $this->save($user);

        //If user have invites to folders we should add access to these folders for this user
        $this->resolveInvites($user);


        $config = Zend_Controller_Front::getInstance()->getParam('bootstrap')->getApplication()->getOptions();
        $options = array(
            'from' => $config['emails']['noreply'],
            'noreply' => $config['emails']['noreply']
        );

        User_Model_Mail::register($user, $options);

        $userId = $user->getId();
        $userEmail = $user->getEmail();
        Zend_Registry::get('logger')->info("User: $userId <$userEmail>. New registration");
        return $user;
    }

    /**
     * Unsubscribe user from document $entryType with id $entryId. If its folder it also unsubscribes from children items
     * @param int $entryId
     * @param string $entryType
     * @param User_Model_User $user
     */
    public function unsubscribe(Qliff_Model_ModelAbstract $model, $entryType, User_Model_User $user) {
        $entryId = $model->getId();
        $userId = $user->getId();
        $userEmail = $user->getEmail();
        $accessMapper = new User_Model_Mapper_Access();
        $permTable = new Views_Model_DbTable_Permissions();
        $permTable->delete("entry_id = '$entryId' AND entry_type='$entryType' AND user_id='$userId'");

        $cache = Zend_Registry::get('cache_default');

        if ($entryType == 'folder') {
            $accessMapper->remove($entryId, $entryType, $userId);
            foreach($model->getLinearFolders() as $folder) {
                $accessMapper->remove($folder->getId(), 'folder', $userId);
                foreach($folder->getDiscussions() as $discussion) {
                    $accessMapper->remove($discussion->getId(), 'discussion', $userId);
                }
                foreach($folder->getFiles() as $file) {
                    $accessMapper->remove($file->getId(), 'file', $userId);
                }
            }

            foreach($model->getDiscussions() as $discussion) {
                $accessMapper->remove($discussion->getId(), 'discussion', $userId);
            }

            foreach($model->getFiles() as $file) {
                $accessMapper->remove($file->getId(), 'file', $userId);
            }

            $cache->clean(
                Zend_Cache::CLEANING_MODE_MATCHING_TAG,
                array('tag_folder_' . $model->getRootId())
            );

        } else {
            $accessMapper->remove($entryId, $entryType, $userId);
            $cache->clean(
                Zend_Cache::CLEANING_MODE_MATCHING_TAG,
                array('tag_folder_' . $model->getFolder()->getRootId())
            );
        }

        $this->getDbTable()->update(array("rebuild_perms" => 1), "id=" . $userId);
        Zend_Registry::get('logger')->info("User: $userId <$userEmail> unsubscribed from $entryType: $entryId");
    }

    /**
     * If user was invited and now he is in the system then resolve all access
     * data to documents for him
     *
     * @param User_Model_User $user
     */
    public function resolveInvites(User_Model_User $user) {
        $db = $this->getDbTable()->getAdapter();
        $email = $db->quote($user->getEmail());

        $this->initPermissions($user);

        $cache = Zend_Registry::get('cache_default');

        $select = $db->select()->from(array('i' => 'invites'))
               ->where("email=$email")
               ->where("accepted=0");

        $result = $select->query()->fetchAll(Zend_Db::FETCH_OBJ);

        if (is_array($result)) {
            foreach($result as $row) {
                try {
                    $permTable = new Views_Model_DbTable_Permissions();
                    $permTable->insert(array(
                        'entry_id' => $row->entry_id,
                        'entry_type' => $row->entry_type,
                        'user_id' => $user->getId(),
                        'access' =>  $row->access
                    ));
                    if ($row->entry_type == 'folder') {
                        $cache->clean(
                            Zend_Cache::CLEANING_MODE_MATCHING_TAG,
                            array('tag_folder_' . $row->entry_id)
                        );
                    }
                    $user->setPermission($row->entry_id, $row->entry_type, $row->access);
                } catch (Zend_Db_Exception $e) {
                    //Can be double record
                }
            }
        }

        $id = (int)$user->getId();

        $cache->clean(
                Zend_Cache::CLEANING_MODE_MATCHING_TAG,
                array('user_document_' . $user->getId())
        );

        $this->_observable->setUser($user);
        $this->_observable->notify();
        $user = $this->_observable->getUser();


        $db->update('users', array('rebuild_perms' => 1), "id=$id");
        $db->update('invites', array('accepted' => 1), "email=$email");
    }

    /**
     * Resolve all access data for all users
     * @deprecated
     */
    public function resolveAllAccess() {
        $users = $this->getDbTable()->fetchAll();
        foreach($users as $user) {
            $u = new User_Model_User();
            $u = $this->fetch($user->id, $u);
            $this->initPermissions($u);
            $this->_observable->setUser($u);
            $this->_observable->notify();
            $user = $this->_observable->getUser();
        }
    }

    /**
     * Invite user to collaborate document $model with access $access
     *
     * @param User_Model_User $inviter
     * @param string $email
     * @param string $entryType
     * @param Qliff_Model_ModelAbstract $model
     * @param string $access edit|view
     */
    public function invite(User_Model_User $inviter, $email, $entryType, Qliff_Model_ModelAbstract $model, $access) {
        $options = array();
        $entryId = $model->getId();

        $db = $this->getDbTable()->getAdapter();

        if (is_string($email)) {
            if (null !== ($user = $this->fetchByEmail($email, new User_Model_User()))) {
                //BlackList

                $mapper = new User_Model_Mapper_BlackList();
                $blackList = $mapper->fetchByUser($user);
                foreach($blackList as $blEmail) {
                    if ($blEmail['email'] == $inviter->getEmail()) {
                        //can't be invited
                        return;
                    }
                }


                $this->resolveInvites($user);
                $cache = Zend_Registry::get('cache_default');
                $cache->clean(
                    Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG,
                    array('user_document_' . $user->getId())
                );
                $cleanTag = null;
                switch (get_class($model)) {
                    case 'Views_Model_Folder':
                        $cleanTag = 'tag_folder_' . $model->getRootId();
                        $cache->remove('access_fetchUsers_' . $model->getId() . '_folder');
                        break;
                    case 'Views_Model_File':
                        $cache->remove('access_fetchUsers_' . $model->getId() . '_file');
                        $cleanTag = 'tag_folder_' . $model->getFolder()->getRootId();
                        break;
                    case 'Views_Model_Discussion':
                        $cache->remove('access_fetchUsers_' . $model->getId() . '_discussion');
                        $cleanTag = 'tag_folder_' . $model->getFolder()->getRootId();
                        break;
                }
                if ($cleanTag) {
                    $cache->clean(
                        Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG,
                        array($cleanTag)
                    );
                }

                $options['user'] = $user;
            }

            $db->insert('invites', array(
                'email' => $email,
                'entry_id' => (int)$entryId,
                'entry_type' => $entryType,
                'user_id' => $inviter->getId(),
                'timestamp_sent' => time(),
                'access' => $access,
                'accepted' => 0
            ));

            User_Model_Mail::invite($inviter, $model, $email, $options);
            $userId = $inviter->getId();
            Zend_Registry::get('logger')->info("User: $userId. Invite sent to: $email");
        } else if (is_array($email)) {
            $inviteList = array();
            $options = array();
            $cache = Zend_Registry::get('cache_default');
            $cleanTag = null;
            switch (get_class($model)) {
                case 'Views_Model_Folder':
                    $cleanTag = 'tag_folder_' . $model->getRootId();
                    $cache->remove('access_fetchUsers_' . $model->getId() . '_folder');
                    break;
                case 'Views_Model_File':
                    $cache->remove('access_fetchUsers_' . $model->getId() . '_file');
                    $cleanTag = 'tag_folder_' . $model->getFolder()->getRootId();
                    break;
                case 'Views_Model_Discussion':
                    $cache->remove('access_fetchUsers_' . $model->getId() . '_discussion');
                    $cleanTag = 'tag_folder_' . $model->getFolder()->getRootId();
                    break;
            }
            if ($cleanTag) {
                $cache->clean(
                        Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG,
                        array($cleanTag)
                );
            }
            foreach ($email as $e) {
                $db->insert('invites', array(
                    'email' => $e,
                    'entry_id' => (int)$entryId,
                    'entry_type' => $entryType,
                    'user_id' => $inviter->getId(),
                    'timestamp_sent' => time(),
                    'access' => $access,
                    'accepted' => 0
                ));
                if (null !== ($user = $this->fetchByEmail($e, new User_Model_User()))) {
                    $mapper = new User_Model_Mapper_BlackList();
                    $blackList = $mapper->fetchByUser($user);
                    $found = false;
                    foreach($blackList as $blEmail) {
                        if ($blEmail['email'] == $inviter->getEmail()) {
                            $found = true;
                        }
                    }

                    if ($found) {
                        //Means in blacklist
                        break;
                    }

                    $this->resolveInvites($user);

                    $cache->clean(
                        Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG,
                        array('user_document_' . $user->getId())
                    );

                    $options['users'][] = $user;
                }
                $inviteList[] = $e;
            }
            User_Model_Mail::massInvite($inviter, $model, $inviteList, $options);
            $userId = $inviter->getId();
            $emailsList = implode(', ', $inviteList);
            Zend_Registry::get('logger')->info("User: $userId. Invites sent to: $emailsList");
        }
    }

    public function inviteSuggest(User_Model_User $inviter, $email, $entryType, Qliff_Model_ModelAbstract $model, $access) {
        $options = array();
        $entryId = $model->getId();

        $db = $this->getDbTable()->getAdapter();

        switch (get_class($model)) {
            case 'Views_Model_Folder':
                $ownerId = $model->getRootFolder()->getOwner()->getId();
                break;
            case 'Views_Model_File':
            case 'Views_Model_Discussion':
                $ownerId = $model->getFolder()->getRootFolder()->getOwner()->getId();
                break;
        }

        if (is_string($email)) {
            $db->insert('invitee_suggest', array(
                'emails' => $email,
                'entry_id' => (int)$entryId,
                'entry_type' => $entryType,
                'user_id' => $inviter->getId(),
                'timestamp_sent' => time(),
                'access' => $access,
                'to_user_id' => $ownerId
            ));
        } else if (is_array($email)) {
            $db->insert('invitee_suggest', array(
                 'emails' => implode(',', $email),
                 'entry_id' => (int) $entryId,
                 'entry_type' => $entryType,
                 'user_id' => $inviter->getId(),
                 'timestamp_sent' => time(),
                 'access' => $access,
                 'to_user_id' => $ownerId
            ));
        }
    }

    public function getSuggestions(User_Model_User $user) {
        $db = $this->getDbTable()->getAdapter();

        $select = $db->select()->from('invitee_suggest')->where("to_user_id=?", $user->getId(), Zend_Db::INT_TYPE);

        $result = $select->query()->fetchAll();

        $suggestions = array();
        if ($result) {
            foreach($result as $row) {
                $suggestions[$row['id']] = $row;
            }
        }

        return $suggestions;
    }

    public function actionSuggestions(User_Model_User $user, $action, array $ids) {
        $suggestions = $this->getSuggestions($user);
        $db = $this->getDbTable()->getAdapter();

        switch($action) {
            case 'approve':
                foreach($ids as $id) {
                    $model = Views_Model_Mapper_Factory::factoryModel(
                        $suggestions[$id]['entry_id'],
                        $suggestions[$id]['entry_type'],
                        $user
                    );

                    $this->invite($user,
                            explode(',', $suggestions[$id]['emails']),
                            $suggestions[$id]['entry_type'],
                            $model,
                            $suggestions[$id]['access']);
                }
                if (!empty ($ids)) {
                    $db->delete('invitee_suggest', 'id IN (' . implode(',', $ids) . ')');
                }
                break;
            case 'decline':
                if (!empty ($ids)) {
                    $db->delete('invitee_suggest', 'id IN (' . implode(',', $ids) . ')');
                }
                break;
        }
    }

    /**
     * Initialize permissions for user $user
     *
     * @param User_Model_User $user
     */
    public function initPermissions(User_Model_User &$user) {
        $user->unsetPermissions();
        $db = $this->getDbTable()->getAdapter();
        $select = $db->select()
                ->from(array('p' => 'permissions'))
                ->where("p.user_id = " . (int)$user->getId());

        $result = $select->query()->fetchAll();

        $permissions = array();
        foreach($result as $row) {
            $permissions[] = array(
                'id' => $row['entry_id'],
                'type' => $row['entry_type'],
                'access' => $row['access']
            );
        }

        $user->setPermissions($permissions);
    }

    /**
     * Activate user and set status to 1 (active)
     * @param string $email
     * @param string $code
     * @return User_Model_User if success and null otherwise
     */
    public function activate($email, $code) {
        if (null === ($user = $this->fetchByEmail($email, new User_Model_User()))) {
            throw new User_Model_Exception(sprintf($this->_messages['user_not_found'], $email));
        } else {
            if ($user->getActivationCode() == '' || $user->getStatus() == 1) {
                throw new User_Model_Exception($this->_messages['user_activated_already']);
            } else {
                //Activation code is not empty and user is blocked
                $user->setActivationCode('');
                $user->setStatus(1);
                $this->save($user);

                $userId = $user->getId();
                Zend_Registry::get('logger')->info("User: $userId. Activation success");

                return $user;
            }
        }
        return null;
    }

    /**
     * Generates activation code based on user email and random data
     *
     * @param string $email
     * @return string
     */
    protected function _generateActivationCode($email) {
        return substr(md5($email . time() . srand()), 0, 16);
    }

    /**
     * Get user by email (its unique)
     *
     * @param string $email
     * @param User_Model_User $user
     * @return User_Model_User
     */
    public function fetchByEmail($email, User_Model_User $user) {
        $email = $this->getDbTable()->getAdapter()->quote($email);
        $users = $this->getUsers('u.email = ' . $email);

        if (empty($users)) {
            return null;
        }

        $user = current($users);
        $this->initPermissions($user);
        $this->initUpdates($user);

        return $user;
    }

    public function initUpdates(User_Model_User &$user) {
        $mapper = new User_Model_Mapper_UserUpdate();
        $user = $mapper->loadUpdates($user);
    }

    /**
     * Get user by unique id $id
     *
     * @param int $id
     * @param User_Model_User $user
     * @param bool $cached Use cache or not
     * @return User_Model_User
     */
    public function fetch($id, User_Model_User $user, $cached = true) {
        if (isset(self::$_users[$id]) && $cached) {
            return self::$_users[$id];
        }

        $cacheId = 'user_' . $id;
        $cache = Zend_Registry::get('cache_default');

        if (false !== ($u = $cache->load($cacheId)) && $cached) {
            self::$_users[$id] = $u;
            return $u;
        }

        $id = $this->getDbTable()->getAdapter()->quote($id, Zend_Db::INT_TYPE);
        $users = $this->getUsers('u.id = ' . $id);
        if (empty($users)) {
            return null;
        }

        $user = current($users);

        $this->initPermissions($user);
        $this->initUpdates($user);

        self::$_users[$id] = $user;
        $cache->save($user, $cacheId);
        return $user;
    }

    /**
     * Save user to database. If user model have id then update it, otherwise insert
     *
     * @param User_Model_User $user
     * @return User_Model_User
     */
    public function save(User_Model_User $user) {
        $data = array(
            'email' => $user->getEmail(),
            'password' => $user->getPassword(),
            'status' => $user->getStatus(),
            'username' => $user->getName(),
            'first_name' => $user->getFirstName(),
            'last_name' => $user->getLastName(),
            'country' => $user->getCountry(),
            'timestamp_login' => $user->getTimestampLogin(),
            'activation_code' => $user->getActivationCode(),
            'notify' => $user->getNotify(),
            'rebuild' => 1
        );

        $roles = $user->getRoles();
        unset($roles[1]); //unset anonymous

        if (null === ($id = $user->getId())) {
            $data['timestamp_reg'] = $user->getTimestampReg();
            $data['status'] = $user->getStatus() ? 1 : 0;
            $data['timestamp_login'] = 0;
            $newId = $this->getDbTable()->insert($data);
            $user->setId($newId);
            foreach($roles as $role => $roleName) {
                $this->getDbTable()->getAdapter()->insert('user_roles',
                    array('user_id' => $newId, 'role_id' => $role)
                );
            }
        } else {
            $id = $this->getDbTable()->getAdapter()->quote($id, Zend_Db::INT_TYPE);
            $this->getDbTable()->update($data, array("id = $id"));

            $dbRolesResult = $this->getDbTable()->getAdapter()->fetchAll("SELECT role_id FROM user_roles WHERE user_id='$id'");
            $dbRoles = array();
            if ($dbRolesResult) {
                 foreach($dbRolesResult as $role) {
                     $dbRoles[$role['role_id']] = $role['role_id'];
                 }
            }

            $unusedRoles = $dbRoles;
            foreach($roles as $role => $roleName) {
                if (!in_array($role, $dbRoles)) {
                    $this->getDbTable()->getAdapter()->insert('user_roles',
                        array('user_id' => $id, 'role_id' => $role)
                    );
                }
                unset($unusedRoles[$role]);
            }

            foreach($unusedRoles as $roleId) {
                $this->getDbTable()->getAdapter()->delete('user_roles', "user_id='$id' AND role_id='$roleId'");
            }
        }

        unset(self::$_users[$user->getId()]);
        $cache = Zend_Registry::get('cache_default');
        $cache->remove('user_' . $user->getId());

        return $user;
    }

    /**
     * Fully remove user with all ties and his files from the system
     *
     * @param int $id User ID
     */
    public function removeUser($id) {
        $db = $this->getDbTable()->getAdapter();
        $id = $db->quote($id, Zend_Db::INT_TYPE);
        $files = $db->fetchAll("SELECT id, path FROM files WHERE user_id=$id");

        $config = Zend_Registry::get('config');
        $basePathFiles = $config['site']['filepath'];

        $fileIds = array();
        foreach($files as $file) {
            $filepath = $basePathFiles . '/' . $file['path'];
            if (file_exists($filepath) && is_writable($filepath)) {
                unlink($filepath);
            }
            $fileIds[] = $file['id'];
        }

        if ($fileIds) {
            $fileIdsString = implode(', ', $fileIds);
            $db->delete('files', "id IN (". $fileIdsString .")");
            $db->delete('access', "entry_id IN (". $fileIdsString .") AND entry_type='file'");
            $db->delete('collaborate_rules', "entry_id IN (". $fileIdsString .") AND entry_type='file'");
            $db->delete('comments', "entry_id IN (". $fileIdsString .") AND entry_type='file'");
            $db->delete('image_notes', "file_id IN (". $fileIdsString .")");
            $db->delete('permissions', "entry_id IN (". $fileIdsString .") AND entry_type='file'");
        }

        $db->delete('access', "user_id=$id");
        $db->delete('permissions', "user_id=$id");
        $db->delete('comments', "user_id=$id");
        $db->delete('image_notes', "user_id=$id");
        $db->delete('user_blacklist', "user_id=$id");
        $db->delete('user_roles', "user_id=$id");
        $db->delete('user_updates', "user_id=$id");
        $db->delete('invitee_suggest', "to_user_id=$id");
        $db->delete('collaborate_rules', "user_id=$id");

        $this->getDbTable()->delete("id=$id");

        $cache = Zend_Registry::get('cache_default');
        $cache->remove('user_' . $id);
        $cache->clean(
                    Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG,
                    array('user_document_' . $id)
                );
    }
}