<?php

/**
 * @file
 * TeamSpeak 3 PHP Framework
 * $Id: Server.php 06/06/2016 22:27:13 scp@Svens-iMac $
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 * @package   TeamSpeak3
 * @version   1.1.24
 * @author    Sven 'ScP' Paulsen
 * @copyright Copyright (c) 2010 by Planet TeamSpeak. All rights reserved.
 */

/**
 * @class TeamSpeak3_Node_Server
 * @brief Class describing a TeamSpeak 3 virtual server and all it's parameters.
 */
class TeamSpeak3_Node_Server extends TeamSpeak3_Node_Abstract
{
    /**
     * @ignore
     */
    protected $channelList = null;

    /**
     * @ignore
     */
    protected $clientList = null;

    /**
     * @ignore
     */
    protected $sgroupList = null;

    /**
     * @ignore
     */
    protected $cgroupList = null;

    /**
     * The TeamSpeak3_Node_Server constructor.
     *
     * @param  TeamSpeak3_Node_Host $host
     * @param  array                $info
     * @param  string               $index
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return TeamSpeak3_Node_Server
     */
    public function __construct(TeamSpeak3_Node_Host $host, array $info, $index = 'virtualserver_id')
    {
        $this->parent   = $host;
        $this->nodeInfo = $info;

        if (!array_key_exists($index, $this->nodeInfo)) {
            throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid serverID', 0x400);
        }

        $this->nodeId = $this->nodeInfo[$index];
    }

    /**
     * Sends a prepared command to the server and returns the result.
     *
     * @param  string $cmd
     * @param  bool   $throw
     * @return TeamSpeak3_Adapter_ServerQuery_Reply
     */
    public function request($cmd, $throw = true)
    {
        if ($this->getId() != $this->getParent()->serverSelectedId()) {
            $this->getParent()->serverSelect($this->getId());
        }

        return $this->getParent()->request($cmd, $throw);
    }

    /**
     * Returns an array filled with TeamSpeak3_Node_Channel objects.
     *
     * @param  array $filter
     * @return array|TeamSpeak3_Node_Channel[]
     */
    public function channelList(array $filter = [])
    {
        if ($this->channelList === null) {
            $channels = $this->request('channellist -topic -flags -voice -limits -icon')->toAssocArray('cid');

            $this->channelList = [];

            foreach ($channels as $cid => $channel) {
                $this->channelList[$cid] = new TeamSpeak3_Node_Channel($this, $channel);
            }

            $this->resetNodeList();
        }

        return $this->filterList($this->channelList, $filter);
    }

    /**
     * Resets the list of channels online.
     *
     * @return void
     */
    public function channelListReset()
    {
        $this->resetNodeList();
        $this->channelList = null;
    }

    /**
     * Creates a new channel using given properties and returns the new ID.
     *
     * @param  array $properties
     * @return int
     */
    public function channelCreate(array $properties)
    {
        $cid = $this->execute('channelcreate', $properties)->toList();
        $this->channelListReset();

        if (!isset($properties['channel_flag_permanent']) && !isset($properties['channel_flag_semi_permanent'])) {
            $this->getParent()->whoamiSet('client_channel_id', $cid['cid']);
        }

        return $cid['cid'];
    }

    /**
     * Deletes the channel specified by $cid.
     *
     * @param  int  $cid
     * @param  bool $force
     * @return void
     */
    public function channelDelete($cid, $force = false)
    {
        $this->execute('channeldelete', ['cid' => $cid, 'force' => $force]);
        $this->channelListReset();

        if (($cid instanceof TeamSpeak3_Node_Abstract ? $cid->getId() : $cid) == $this->whoamiGet('client_channel_id')) {
            $this->getParent()->whoamiReset();
        }
    }

    /**
     * Moves the channel specified by $cid to the parent channel specified with $pid.
     *
     * @param  int $cid
     * @param  int $pid
     * @param  int $order
     * @return void
     */
    public function channelMove($cid, $pid, $order = null)
    {
        $this->execute('channelmove', ['cid' => $cid, 'cpid' => $pid, 'order' => $order]);
        $this->channelListReset();
    }

    /**
     * Returns TRUE if the given TeamSpeak3_Node_Channel object is a spacer.
     *
     * @param  TeamSpeak3_Node_Channel $channel
     * @return bool
     */
    public function channelIsSpacer(TeamSpeak3_Node_Channel $channel)
    {
        return (preg_match("/\[[^\]]*spacer[^\]]*\]/", $channel) && $channel['channel_flag_permanent'] && !$channel['pid']) ? true : false;
    }

    /**
     * Creates a new channel spacer and returns the new ID. The first parameter $ident is used to create a
     * unique spacer name on the virtual server.
     *
     * @param  string $ident
     * @param  mixed  $type
     * @param  int    $align
     * @param  int    $order
     * @param  int    $maxclients
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return int
     */
    public function channelSpacerCreate($ident, $type = TeamSpeak3::SPACER_SOLIDLINE, $align = TeamSpeak3::SPACER_ALIGN_REPEAT, $order = null, $maxclients = 0)
    {
        $properties = ['channel_name_phonetic' => 'channel spacer', 'channel_codec' => TeamSpeak3::CODEC_OPUS_VOICE, 'channel_codec_quality' => 0x00, 'channel_flag_permanent' => true, 'channel_flag_maxclients_unlimited' => false, 'channel_flag_maxfamilyclients_unlimited' => false, 'channel_flag_maxfamilyclients_inherited' => false, 'channel_maxclients' => $maxclients, 'channel_order' => $order];

        switch ($align) {
            case TeamSpeak3::SPACER_ALIGN_REPEAT:
                $properties['channel_name'] = '[*spacer' . (string) $ident . ']';
                break;

            case TeamSpeak3::SPACER_ALIGN_LEFT:
                $properties['channel_name'] = '[lspacer' . (string) $ident . ']';
                break;

            case TeamSpeak3::SPACER_ALIGN_RIGHT:
                $properties['channel_name'] = '[rspacer' . (string) $ident . ']';
                break;

            case TeamSpeak3::SPACER_ALIGN_CENTER:
                $properties['channel_name'] = '[cspacer' . (string) $ident . ']';
                break;

            default:
                throw new TeamSpeak3_Adapter_ServerQuery_Exception('missing required parameter', 0x606);
                break;
        }

        switch ($type) {
            case (string) TeamSpeak3::SPACER_SOLIDLINE:
                $properties['channel_name'] .= '___';
                break;

            case (string) TeamSpeak3::SPACER_DASHLINE:
                $properties['channel_name'] .= '---';
                break;

            case (string) TeamSpeak3::SPACER_DOTLINE:
                $properties['channel_name'] .= '...';
                break;

            case (string) TeamSpeak3::SPACER_DASHDOTLINE:
                $properties['channel_name'] .= '-.-';
                break;

            case (string) TeamSpeak3::SPACER_DASHDOTDOTLINE:
                $properties['channel_name'] .= '-..';
                break;

            default:
                $properties['channel_name'] .= (string) $type;
                break;
        }

        return $this->channelCreate($properties);
    }

    /**
     * Returns the possible type of a channel spacer.
     *
     * @param  int $cid
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return int
     */
    public function channelSpacerGetType($cid)
    {
        $channel = $this->channelGetById($cid);

        if (!$this->channelIsSpacer($channel)) {
            throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid channel flags', 0x307);
        }

        switch ($channel['channel_name']->section(']', 1)) {
            case '___':
                return TeamSpeak3::SPACER_SOLIDLINE;

            case '---':
                return TeamSpeak3::SPACER_DASHLINE;

            case '...':
                return TeamSpeak3::SPACER_DOTLINE;

            case '-.-':
                return TeamSpeak3::SPACER_DASHDOTLINE;

            case '-..':
                return TeamSpeak3::SPACER_DASHDOTDOTLINE;

            default:
                return TeamSpeak3::SPACER_CUSTOM;
        }
    }

    /**
     * Returns the possible alignment of a channel spacer.
     *
     * @param  int $cid
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return int
     */
    public function channelSpacerGetAlign($cid)
    {
        $channel = $this->channelGetById($cid);

        if (!$this->channelIsSpacer($channel) || !preg_match("/\[(.*)spacer.*\]/", $channel, $matches) || !isset($matches[1])) {
            throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid channel flags', 0x307);
        }

        switch ($matches[1]) {
            case '*':
                return TeamSpeak3::SPACER_ALIGN_REPEAT;

            case 'c':
                return TeamSpeak3::SPACER_ALIGN_CENTER;

            case 'r':
                return TeamSpeak3::SPACER_ALIGN_RIGHT;

            default:
                return TeamSpeak3::SPACER_ALIGN_LEFT;
        }
    }

    /**
     * Returns a list of permissions defined for a specific channel.
     *
     * @param  int  $cid
     * @param  bool $permsid
     * @return array
     */
    public function channelPermList($cid, $permsid = false)
    {
        return $this->execute('channelpermlist', ['cid' => $cid, $permsid ? '-permsid' : null])->toAssocArray($permsid ? 'permsid' : 'permid');
    }

    /**
     * Adds a set of specified permissions to a channel. Multiple permissions can be added by
     * providing the two parameters of each permission.
     *
     * @param  int $cid
     * @param  int $permid
     * @param  int $permvalue
     * @return void
     */
    public function channelPermAssign($cid, $permid, $permvalue)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? 'permid' : 'permsid';
        } else {
            $permident = (is_numeric(current($permid))) ? 'permid' : 'permsid';
        }

        $this->execute('channeladdperm', ['cid' => $cid, $permident => $permid, 'permvalue' => $permvalue]);
    }

    /**
     * Removes a set of specified permissions from a channel. Multiple permissions can be removed at once.
     *
     * @param  int $cid
     * @param  int $permid
     * @return void
     */
    public function channelPermRemove($cid, $permid)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? 'permid' : 'permsid';
        } else {
            $permident = (is_numeric(current($permid))) ? 'permid' : 'permsid';
        }

        $this->execute('channeldelperm', ['cid' => $cid, $permident => $permid]);
    }

    /**
     * Returns a list of permissions defined for a client in a specific channel.
     *
     * @param  int  $cid
     * @param  int  $cldbid
     * @param  bool $permsid
     * @return array
     */
    public function channelClientPermList($cid, $cldbid, $permsid = false)
    {
        return $this->execute('channelclientpermlist', ['cid' => $cid, 'cldbid' => $cldbid, $permsid ? '-permsid' : null])->toAssocArray($permsid ? 'permsid' : 'permid');
    }

    /**
     * Adds a set of specified permissions to a client in a specific channel. Multiple permissions can be added by
     * providing the two parameters of each permission.
     *
     * @param  int $cid
     * @param  int $cldbid
     * @param  int $permid
     * @param  int $permvalue
     * @return void
     */
    public function channelClientPermAssign($cid, $cldbid, $permid, $permvalue)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? 'permid' : 'permsid';
        } else {
            $permident = (is_numeric(current($permid))) ? 'permid' : 'permsid';
        }

        $this->execute('channelclientaddperm', ['cid' => $cid, 'cldbid' => $cldbid, $permident => $permid, 'permvalue' => $permvalue]);
    }

    /**
     * Removes a set of specified permissions from a client in a specific channel. Multiple permissions can be removed
     * at once.
     *
     * @param  int $cid
     * @param  int $cldbid
     * @param  int $permid
     * @return void
     */
    public function channelClientPermRemove($cid, $cldbid, $permid)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? 'permid' : 'permsid';
        } else {
            $permident = (is_numeric(current($permid))) ? 'permid' : 'permsid';
        }

        $this->execute('channelclientdelperm', ['cid' => $cid, 'cldbid' => $cldbid, $permident => $permid]);
    }

    /**
     * Returns a list of files and directories stored in the specified channels file repository.
     *
     * @param  int    $cid
     * @param  string $cpw
     * @param  string $path
     * @param  bool   $recursive
     * @return array
     */
    public function channelFileList($cid, $cpw = '', $path = '/', $recursive = false)
    {
        $files = $this->execute('ftgetfilelist', ['cid' => $cid, 'cpw' => $cpw, 'path' => $path])->toArray();
        $count = count($files);

        for ($i = 0; $i < $count; $i++) {
            $files[$i]['sid']  = $this->getId();
            $files[$i]['cid']  = $files[0]['cid'];
            $files[$i]['path'] = $files[0]['path'];
            $files[$i]['src']  = new TeamSpeak3_Helper_String($cid ? $files[$i]['path'] : '/');

            if (!$files[$i]['src']->endsWith('/')) {
                $files[$i]['src']->append('/');
            }

            $files[$i]['src']->append($files[$i]['name']);

            if ($recursive && $files[$i]['type'] == TeamSpeak3::FILE_TYPE_DIRECTORY) {
                $files = array_merge($files, $this->channelFileList($cid, $cpw, $path . $files[$i]['name'], $recursive));
            }
        }

        uasort($files, [__CLASS__, 'sortFileList']);

        return $files;
    }

    /**
     * Returns detailed information about the specified file stored in a channels file repository.
     *
     * @param  int    $cid
     * @param  string $cpw
     * @param  string $name
     * @return array
     */
    public function channelFileInfo($cid, $cpw = '', $name = '/')
    {
        $info = $this->execute('ftgetfileinfo', ['cid' => $cid, 'cpw' => $cpw, 'name' => $name])->toArray();

        return array_pop($info);
    }

    /**
     * Renames a file in a channels file repository. If the two parameters $tcid and $tcpw are specified, the file
     * will be moved into another channels file repository.
     *
     * @param  int    $cid
     * @param  string $cpw
     * @param  string $oldname
     * @param  string $newname
     * @param  int    $tcid
     * @param  string $tcpw
     * @return void
     */
    public function channelFileRename($cid, $cpw = '', $oldname = '/', $newname = '/', $tcid = null, $tcpw = null)
    {
        $this->execute('ftrenamefile', ['cid' => $cid, 'cpw' => $cpw, 'oldname' => $oldname, 'newname' => $newname, 'tcid' => $tcid, 'tcpw' => $tcpw]);
    }

    /**
     * Deletes one or more files stored in a channels file repository.
     *
     * @param  int    $cid
     * @param  string $cpw
     * @param  string $name
     * @return void
     */
    public function channelFileDelete($cid, $cpw = '', $name = '/')
    {
        $this->execute('ftdeletefile', ['cid' => $cid, 'cpw' => $cpw, 'name' => $name]);
    }

    /**
     * Creates new directory in a channels file repository.
     *
     * @param  int    $cid
     * @param  string $cpw
     * @param  string $dirname
     * @return void
     */
    public function channelDirCreate($cid, $cpw = '', $dirname = '/')
    {
        $this->execute('ftcreatedir', ['cid' => $cid, 'cpw' => $cpw, 'dirname' => $dirname]);
    }

    /**
     * Returns the level of a channel.
     *
     * @param  int $cid
     * @return int
     */
    public function channelGetLevel($cid)
    {
        $channel = $this->channelGetById($cid);
        $levelno = 0;

        if ($channel['pid']) {
            $levelno = $this->channelGetLevel($channel['pid']) + 1;
        }

        return $levelno;
    }

    /**
     * Returns the pathway of a channel which can be used as a clients default channel.
     *
     * @param  int $cid
     * @return string
     */
    public function channelGetPathway($cid)
    {
        $channel = $this->channelGetById($cid);
        $pathway = $channel['channel_name'];

        if ($channel['pid']) {
            $pathway = $this->channelGetPathway($channel['pid']) . '/' . $channel['channel_name'];
        }

        return $pathway;
    }

    /**
     * Returns the TeamSpeak3_Node_Channel object matching the given ID.
     *
     * @param  int $cid
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return TeamSpeak3_Node_Channel
     */
    public function channelGetById($cid)
    {
        if (!array_key_exists((string) $cid, $this->channelList())) {
            throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid channelID', 0x300);
        }

        return $this->channelList[(int) ((string) $cid)];
    }

    /**
     * Returns the TeamSpeak3_Node_Channel object matching the given name.
     *
     * @param  string $name
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return TeamSpeak3_Node_Channel
     */
    public function channelGetByName($name)
    {
        foreach ($this->channelList() as $channel) {
            if ($channel['channel_name'] == $name) {
                return $channel;
            }
        }

        throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid channelID', 0x300);
    }

    /**
     * Returns an array filled with TeamSpeak3_Node_Client objects.
     *
     * @param  array $filter
     * @return array|TeamSpeak3_Node_Client[]
     */
    public function clientList(array $filter = [])
    {
        if ($this->clientList === null) {
            $clients = $this->request('clientlist -uid -away -badges -voice -info -times -groups -icon -country -ip')->toAssocArray('clid');

            $this->clientList = [];

            foreach ($clients as $clid => $client) {
                if ($this->getParent()->getExcludeQueryClients() && $client['client_type']) {
                    continue;
                }

                $this->clientList[$clid] = new TeamSpeak3_Node_Client($this, $client);
            }

            uasort($this->clientList, [__CLASS__, 'sortClientList']);

            $this->resetNodeList();
        }

        return $this->filterList($this->clientList, $filter);
    }

    /**
     * Resets the list of clients online.
     *
     * @return void
     */
    public function clientListReset()
    {
        $this->resetNodeList();
        $this->clientList = null;
    }

    /**
     * Returns a list of clients matching a given name pattern.
     *
     * @param  string $pattern
     * @return array
     */
    public function clientFind($pattern)
    {
        return $this->execute('clientfind', ['pattern' => $pattern])->toAssocArray('clid');
    }

    /**
     * Returns a list of client identities known by the virtual server. By default, the server spits out 25 entries
     * at once.
     *
     * @param  int $offset
     * @param  int $limit
     * @return array
     */
    public function clientListDb($offset = null, $limit = null)
    {
        return $this->execute('clientdblist -count', ['start' => $offset, 'duration' => $limit])->toAssocArray('cldbid');
    }

    /**
     * Returns the number of client identities known by the virtual server.
     *
     * @return int
     */
    public function clientCountDb()
    {
        return current($this->execute('clientdblist -count', ['duration' => 1])->toList('count'));
    }

    /**
     * Returns a list of properties from the database for the client specified by $cldbid.
     *
     * @param  int $cldbid
     * @return array
     */
    public function clientInfoDb($cldbid)
    {
        return $this->execute('clientdbinfo', ['cldbid' => $cldbid])->toList();
    }

    /**
     * Returns a list of client database IDs matching a given pattern. You can either search for a clients
     * last known nickname or his unique identity by using the $uid option.
     *
     * @param  string $pattern
     * @param  bool   $uid
     * @return array
     */
    public function clientFindDb($pattern, $uid = false)
    {
        return array_keys($this->execute('clientdbfind', ['pattern' => $pattern, ($uid) ? '-uid' : null])->toAssocArray('cldbid'));
    }

    /**
     * Returns the number of regular clients online.
     *
     * @return int
     */
    public function clientCount()
    {
        if ($this->isOffline()) {
            return 0;
        }

        return $this['virtualserver_clientsonline'] - $this['virtualserver_queryclientsonline'];
    }

    /**
     * Returns the TeamSpeak3_Node_Client object matching the given ID.
     *
     * @param  int $clid
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return TeamSpeak3_Node_Client
     */
    public function clientGetById($clid)
    {
        if (!array_key_exists((string) $clid, $this->clientList())) {
            throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid clientID', 0x200);
        }

        return $this->clientList[(int) ((string) $clid)];
    }

    /**
     * Returns the TeamSpeak3_Node_Client object matching the given name.
     *
     * @param  string $name
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return TeamSpeak3_Node_Client
     */
    public function clientGetByName($name)
    {
        foreach ($this->clientList() as $client) {
            if ($client['client_nickname'] == $name) {
                return $client;
            }
        }

        throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid clientID', 0x200);
    }

    /**
     * Returns the TeamSpeak3_Node_Client object matching the given unique identifier.
     *
     * @param  string $uid
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return TeamSpeak3_Node_Client
     */
    public function clientGetByUid($uid)
    {
        foreach ($this->clientList() as $client) {
            if ($client['client_unique_identifier'] == $uid) {
                return $client;
            }
        }

        throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid clientID', 0x200);
    }

    /**
     * Returns the TeamSpeak3_Node_Client object matching the given database ID.
     *
     * @param  int $dbid
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return TeamSpeak3_Node_Client
     */
    public function clientGetByDbid($dbid)
    {
        foreach ($this->clientList() as $client) {
            if ($client['client_database_id'] == $dbid) {
                return $client;
            }
        }

        throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid clientID', 0x200);
    }

    /**
     * Returns an array containing the last known nickname and the database ID of the client matching
     * the unique identifier specified with $cluid.
     *
     * @param  string $cluid
     * @return array
     */
    public function clientGetNameByUid($cluid)
    {
        return $this->execute('clientgetnamefromuid', ['cluid' => $cluid])->toList();
    }

    /**
     * Returns an array containing a list of active client connections using the unique identifier
     * specified with $cluid.
     *
     * @param  string $cluid
     * @return array
     */
    public function clientGetIdsByUid($cluid)
    {
        return $this->execute('clientgetids', ['cluid' => $cluid])->toAssocArray('clid');
    }

    /**
     * Returns an array containing the last known nickname and the unique identifier of the client
     * matching the database ID specified with $cldbid.
     *
     * @param  string $cldbid
     * @return array
     */
    public function clientGetNameByDbid($cldbid)
    {
        return $this->execute('clientgetnamefromdbid', ['cldbid' => $cldbid])->toList();
    }

    /**
     * Returns an array containing the names and IDs of all server groups the client specified with
     * $cldbid is is currently residing in.
     *
     * @param  string $cldbid
     * @return array
     */
    public function clientGetServerGroupsByDbid($cldbid)
    {
        return $this->execute('servergroupsbyclientid', ['cldbid' => $cldbid])->toAssocArray('sgid');
    }

    /**
     * Moves a client to another channel.
     *
     * @param  int    $clid
     * @param  int    $cid
     * @param  string $cpw
     * @return void
     */
    public function clientMove($clid, $cid, $cpw = null)
    {
        $this->clientListReset();

        $this->execute('clientmove', ['clid' => $clid, 'cid' => $cid, 'cpw' => $cpw]);

        if ($clid instanceof TeamSpeak3_Node_Abstract) {
            $clid = $clid->getId();
        }

        if ($cid instanceof TeamSpeak3_Node_Abstract) {
            $cid = $cid->getId();
        }

        if (!is_array($clid) && $clid == $this->whoamiGet('client_id')) {
            $this->getParent()->whoamiSet('client_channel_id', $cid);
        }
    }

    /**
     * Kicks one or more clients from their currently joined channel or from the server.
     *
     * @param  int    $clid
     * @param  int    $reasonid
     * @param  string $reasonmsg
     * @return void
     */
    public function clientKick($clid, $reasonid = TeamSpeak3::KICK_CHANNEL, $reasonmsg = null)
    {
        $this->clientListReset();

        $this->execute('clientkick', ['clid' => $clid, 'reasonid' => $reasonid, 'reasonmsg' => $reasonmsg]);
    }

    /**
     * Sends a poke message to a client.
     *
     * @param  int    $clid
     * @param  string $msg
     * @return void
     */
    public function clientPoke($clid, $msg)
    {
        $this->execute('clientpoke', ['clid' => $clid, 'msg' => $msg]);
    }

    /**
     * Bans the client specified with ID $clid from the server. Please note that this will create two separate
     * ban rules for the targeted clients IP address and his unique identifier.
     *
     * @param  int    $clid
     * @param  int    $timeseconds
     * @param  string $reason
     * @return array
     */
    public function clientBan($clid, $timeseconds = null, $reason = null)
    {
        $this->clientListReset();

        $bans = $this->execute('banclient', ['clid' => $clid, 'time' => $timeseconds, 'banreason' => $reason])->toAssocArray('banid');

        return array_keys($bans);
    }

    /**
     * Changes the clients properties using given properties.
     *
     * @param  string $cldbid
     * @param  array  $properties
     * @return void
     */
    public function clientModifyDb($cldbid, array $properties)
    {
        $properties['cldbid'] = $cldbid;

        $this->execute('clientdbedit', $properties);
    }

    /**
     * Deletes a clients properties from the database.
     *
     * @param  string $cldbid
     * @return void
     */
    public function clientDeleteDb($cldbid)
    {
        $this->execute('clientdbdelete', ['cldbid' => $cldbid]);
    }

    /**
     * Sets the channel group of a client to the ID specified.
     *
     * @param  int $cldbid
     * @param  int $cid
     * @param  int $cgid
     * @return void
     */
    public function clientSetChannelGroup($cldbid, $cid, $cgid)
    {
        $this->execute('setclientchannelgroup', ['cldbid' => $cldbid, 'cid' => $cid, 'cgid' => $cgid]);
    }

    /**
     * Returns a list of permissions defined for a client.
     *
     * @param  int  $cldbid
     * @param  bool $permsid
     * @return array
     */
    public function clientPermList($cldbid, $permsid = false)
    {
        $this->clientListReset();

        return $this->execute('clientpermlist', ['cldbid' => $cldbid, $permsid ? '-permsid' : null])->toAssocArray($permsid ? 'permsid' : 'permid');
    }

    /**
     * Adds a set of specified permissions to a client. Multiple permissions can be added by providing
     * the three parameters of each permission.
     *
     * @param  int $cldbid
     * @param  int $permid
     * @param  int $permvalue
     * @param  int $permskip
     * @return void
     */
    public function clientPermAssign($cldbid, $permid, $permvalue, $permskip = false)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? 'permid' : 'permsid';
        } else {
            $permident = (is_numeric(current($permid))) ? 'permid' : 'permsid';
        }

        $this->execute('clientaddperm', ['cldbid' => $cldbid, $permident => $permid, 'permvalue' => $permvalue, 'permskip' => $permskip]);
    }

    /**
     * Removes a set of specified permissions from a client. Multiple permissions can be removed at once.
     *
     * @param int $cldbid
     * @param int $permid
     * @return void
     */
    public function clientPermRemove($cldbid, $permid)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? 'permid' : 'permsid';
        } else {
            $permident = (is_numeric(current($permid))) ? 'permid' : 'permsid';
        }

        $this->execute('clientdelperm', ['cldbid' => $cldbid, $permident => $permid]);
    }

    /**
     * Returns a list of server groups available.
     *
     * @param  filter $filter
     * @return array|TeamSpeak3_Node_Servergroup[]
     */
    public function serverGroupList(array $filter = [])
    {
        if ($this->sgroupList === null) {
            $this->sgroupList = $this->request('servergrouplist')->toAssocArray('sgid');

            foreach ($this->sgroupList as $sgid => $group) {
                $this->sgroupList[$sgid] = new TeamSpeak3_Node_Servergroup($this, $group);
            }

            uasort($this->sgroupList, [__CLASS__, 'sortGroupList']);
        }

        return $this->filterList($this->sgroupList, $filter);
    }

    /**
     * Resets the list of server groups.
     *
     * @return void
     */
    public function serverGroupListReset()
    {
        $this->sgroupList = null;
    }

    /**
     * Creates a new server group using the name specified with $name and returns its ID.
     *
     * @param  string $name
     * @param  int    $type
     * @return int
     */
    public function serverGroupCreate($name, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        $this->serverGroupListReset();

        $sgid = $this->execute('servergroupadd', ['name' => $name, 'type' => $type])->toList();

        return $sgid['sgid'];
    }

    /**
     * Creates a copy of an existing server group specified by $ssgid and returns the new groups ID.
     *
     * @param  int    $ssgid
     * @param  string $name
     * @param  int    $tsgid
     * @param  int    $type
     * @return int
     */
    public function serverGroupCopy($ssgid, $name = null, $tsgid = 0, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        $this->serverGroupListReset();

        $sgid = $this->execute('servergroupcopy', ['ssgid' => $ssgid, 'tsgid' => $tsgid, 'name' => $name, 'type' => $type])->toList();

        if ($tsgid && $name) {
            $this->serverGroupRename($tsgid, $name);
        }

        return count($sgid) ? $sgid['sgid'] : (int) $tsgid;
    }

    /**
     * Renames the server group specified with $sgid.
     *
     * @param  int    $sgid
     * @param  string $name
     * @return void
     */
    public function serverGroupRename($sgid, $name)
    {
        $this->serverGroupListReset();

        $this->execute('servergrouprename', ['sgid' => $sgid, 'name' => $name]);
    }

    /**
     * Deletes the server group specified with $sgid. If $force is set to 1, the server group
     * will be deleted even if there are clients within.
     *
     * @param  int  $sgid
     * @param  bool $force
     * @return void
     */
    public function serverGroupDelete($sgid, $force = false)
    {
        $this->serverGroupListReset();

        $this->execute('servergroupdel', ['sgid' => $sgid, 'force' => $force]);
    }

    /**
     * Returns the TeamSpeak3_Node_Servergroup object matching the given ID.
     *
     * @param  int $sgid
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return TeamSpeak3_Node_Servergroup
     */
    public function serverGroupGetById($sgid)
    {
        if (!array_key_exists((string) $sgid, $this->serverGroupList())) {
            throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid groupID', 0xA00);
        }

        return $this->sgroupList[(int) ((string) $sgid)];
    }

    /**
     * Returns the TeamSpeak3_Node_Servergroup object matching the given name.
     *
     * @param  string $name
     * @param  int    $type
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return TeamSpeak3_Node_Servergroup
     */
    public function serverGroupGetByName($name, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        foreach ($this->serverGroupList() as $group) {
            if ($group['name'] == $name && $group['type'] == $type) {
                return $group;
            }
        }

        throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid groupID', 0xA00);
    }

    /**
     * Returns a list of permissions assigned to the server group specified.
     *
     * @param  int  $sgid
     * @param  bool $permsid
     * @return array
     */
    public function serverGroupPermList($sgid, $permsid = false)
    {
        return $this->execute('servergrouppermlist', ['sgid' => $sgid, $permsid ? '-permsid' : null])->toAssocArray($permsid ? 'permsid' : 'permid');
    }

    /**
     * Adds a set of specified permissions to the server group specified. Multiple permissions
     * can be added by providing the four parameters of each permission in separate arrays.
     *
     * @param  int $sgid
     * @param  int $permid
     * @param  int $permvalue
     * @param  int $permnegated
     * @param  int $permskip
     * @return void
     */
    public function serverGroupPermAssign($sgid, $permid, $permvalue, $permnegated = false, $permskip = false)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? 'permid' : 'permsid';
        } else {
            $permident = (is_numeric(current($permid))) ? 'permid' : 'permsid';
        }

        $this->execute('servergroupaddperm', ['sgid' => $sgid, $permident => $permid, 'permvalue' => $permvalue, 'permnegated' => $permnegated, 'permskip' => $permskip]);
    }

    /**
     * Removes a set of specified permissions from the server group specified with $sgid. Multiple
     * permissions can be removed at once.
     *
     * @param  int $sgid
     * @param  int $permid
     * @return void
     */
    public function serverGroupPermRemove($sgid, $permid)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? 'permid' : 'permsid';
        } else {
            $permident = (is_numeric(current($permid))) ? 'permid' : 'permsid';
        }

        $this->execute('servergroupdelperm', ['sgid' => $sgid, $permident => $permid]);
    }

    /**
     * Returns a list of clients assigned to the server group specified.
     *
     * @param  int $sgid
     * @return array
     */
    public function serverGroupClientList($sgid)
    {
        if ($this['virtualserver_default_server_group'] == $sgid) {
            return [];
        }

        return $this->execute('servergroupclientlist', ['sgid' => $sgid, '-names'])->toAssocArray('cldbid');
    }

    /**
     * Adds a client to the server group specified. Please note that a client cannot be
     * added to default groups or template groups.
     *
     * @param  int $sgid
     * @param  int $cldbid
     * @return void
     */
    public function serverGroupClientAdd($sgid, $cldbid)
    {
        $this->clientListReset();

        $this->execute('servergroupaddclient', ['sgid' => $sgid, 'cldbid' => $cldbid]);
    }

    /**
     * Removes a client from the server group specified.
     *
     * @param  int $sgid
     * @param  int $cldbid
     * @return void
     */
    public function serverGroupClientDel($sgid, $cldbid)
    {
        $this->execute('servergroupdelclient', ['sgid' => $sgid, 'cldbid' => $cldbid]);
    }

    /**
     * Returns an ordered array of regular server groups available based on a pre-defined
     * set of rules.
     *
     * @return array
     */
    public function serverGroupGetProfiles()
    {
        $profiles = [];

        foreach ($this->serverGroupList() as $sgid => $sgroup) {
            if ($sgroup['type'] != TeamSpeak3::GROUP_DBTYPE_REGULAR) {
                continue;
            }

            $profiles[$sgid] = ['b_permission_modify_power_ignore' => 0, 'i_group_needed_member_add_power' => 0, 'i_group_member_add_power' => 0, 'i_group_needed_member_remove_power' => 0, 'i_group_member_remove_power' => 0, 'i_needed_modify_power_count' => 0, 'i_needed_modify_power_total' => 0, 'i_permission_modify_power' => 0, 'i_group_needed_modify_power' => 0, 'i_group_modify_power' => 0, 'i_client_needed_modify_power' => 0, 'i_client_modify_power' => 0, 'b_virtualserver_servergroup_create' => 0, 'b_virtualserver_servergroup_delete' => 0, 'b_client_ignore_bans' => 0, 'b_client_ignore_antiflood' => 0, 'b_group_is_permanent' => 0, 'i_client_needed_ban_power' => 0, 'i_client_needed_kick_power' => 0, 'i_client_needed_move_power' => 0, 'i_client_talk_power' => 0, '__sgid' => $sgid, '__name' => $sgroup->toString(), '__node' => $sgroup];

            try {
                $perms = $this->serverGroupPermList($sgid, true);
                $grant = isset($perms['i_permission_modify_power']) ? $perms['i_permission_modify_power']['permvalue'] : null;
            } catch (TeamSpeak3_Adapter_ServerQuery_Exception $e) {
                /* ERROR_database_empty_result */
                if ($e->getCode() != 0x501) {
                    throw $e;
                }
                $perms = [];
                $grant = null;
            }

            foreach ($perms as $permsid => $perm) {
                if (in_array($permsid, array_keys($profiles[$sgid]))) {
                    $profiles[$sgid][$permsid] = $perm['permvalue'];
                } elseif (TeamSpeak3_Helper_String::factory($permsid)->startsWith('i_needed_modify_power_')) {
                    if (!$grant || $perm['permvalue'] > $grant) {
                        continue;
                    }

                    $profiles[$sgid]['i_needed_modify_power_total'] = $profiles[$sgid]['i_needed_modify_power_total'] + $perm['permvalue'];
                    $profiles[$sgid]['i_needed_modify_power_count']++;
                }
            }
        }

        array_multisort($profiles, SORT_DESC);

        return $profiles;
    }

    /**
     * Tries to identify the post powerful/weakest server group on the virtual server and returns
     * the ID.
     *
     * @param  int $mode
     * @return TeamSpeak3_Node_Servergroup
     */
    public function serverGroupIdentify($mode = TeamSpeak3::GROUP_IDENTIFIY_STRONGEST)
    {
        $profiles = $this->serverGroupGetProfiles();

        $best_guess_profile = ($mode == TeamSpeak3::GROUP_IDENTIFIY_STRONGEST) ? array_shift($profiles) : array_pop($profiles);

        return $this->serverGroupGetById($best_guess_profile['__sgid']);
    }

    /**
     * Returns a list of channel groups available.
     *
     * @param  array $filter
     * @return array|TeamSpeak3_Node_Channelgroup[]
     */
    public function channelGroupList(array $filter = [])
    {
        if ($this->cgroupList === null) {
            $this->cgroupList = $this->request('channelgrouplist')->toAssocArray('cgid');

            foreach ($this->cgroupList as $cgid => $group) {
                $this->cgroupList[$cgid] = new TeamSpeak3_Node_Channelgroup($this, $group);
            }

            uasort($this->cgroupList, [__CLASS__, 'sortGroupList']);
        }

        return $this->filterList($this->cgroupList, $filter);
    }

    /**
     * Resets the list of channel groups.
     *
     * @return void
     */
    public function channelGroupListReset()
    {
        $this->cgroupList = null;
    }

    /**
     * Creates a new channel group using the name specified with $name and returns its ID.
     *
     * @param  string $name
     * @param  int    $type
     * @return int
     */
    public function channelGroupCreate($name, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        $this->channelGroupListReset();

        $cgid = $this->execute('channelgroupadd', ['name' => $name, 'type' => $type])->toList();

        return $cgid['cgid'];
    }

    /**
     * Creates a copy of an existing channel group specified by $scgid and returns the new groups ID.
     *
     * @param  int    $scgid
     * @param  string $name
     * @param  int    $tcgid
     * @param  int    $type
     * @return int
     */
    public function channelGroupCopy($scgid, $name = null, $tcgid = 0, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        $this->channelGroupListReset();

        $cgid = $this->execute('channelgroupcopy', ['scgid' => $scgid, 'tcgid' => $tcgid, 'name' => $name, 'type' => $type])->toList();

        if ($tcgid && $name) {
            $this->channelGroupRename($tcgid, $name);
        }

        return count($cgid) ? $cgid['cgid'] : (int) $tcgid;
    }

    /**
     * Renames the channel group specified with $cgid.
     *
     * @param  int    $cgid
     * @param  string $name
     * @return void
     */
    public function channelGroupRename($cgid, $name)
    {
        $this->channelGroupListReset();

        $this->execute('channelgrouprename', ['cgid' => $cgid, 'name' => $name]);
    }

    /**
     * Deletes the channel group specified with $cgid. If $force is set to 1, the channel group
     * will be deleted even if there are clients within.
     *
     * @param  int  $sgid
     * @param  bool $force
     * @param mixed $cgid
     * @return void
     */
    public function channelGroupDelete($cgid, $force = false)
    {
        $this->channelGroupListReset();

        $this->execute('channelgroupdel', ['cgid' => $cgid, 'force' => $force]);
    }

    /**
     * Returns the TeamSpeak3_Node_Channelgroup object matching the given ID.
     *
     * @param  int $cgid
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return TeamSpeak3_Node_Channelgroup
     */
    public function channelGroupGetById($cgid)
    {
        if (!array_key_exists((string) $cgid, $this->channelGroupList())) {
            throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid groupID', 0xA00);
        }

        return $this->cgroupList[(int) ((string) $cgid)];
    }

    /**
     * Returns the TeamSpeak3_Node_Channelgroup object matching the given name.
     *
     * @param  string $name
     * @param  int    $type
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return TeamSpeak3_Node_Channelgroup
     */
    public function channelGroupGetByName($name, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        foreach ($this->channelGroupList() as $group) {
            if ($group['name'] == $name && $group['type'] == $type) {
                return $group;
            }
        }

        throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid groupID', 0xA00);
    }

    /**
     * Returns a list of permissions assigned to the channel group specified.
     *
     * @param  int  $cgid
     * @param  bool $permsid
     * @return array
     */
    public function channelGroupPermList($cgid, $permsid = false)
    {
        return $this->execute('channelgrouppermlist', ['cgid' => $cgid, $permsid ? '-permsid' : null])->toAssocArray($permsid ? 'permsid' : 'permid');
    }

    /**
     * Adds a set of specified permissions to the channel group specified. Multiple permissions
     * can be added by providing the two parameters of each permission in separate arrays.
     *
     * @param  int $cgid
     * @param  int $permid
     * @param  int $permvalue
     * @return void
     */
    public function channelGroupPermAssign($cgid, $permid, $permvalue)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? 'permid' : 'permsid';
        } else {
            $permident = (is_numeric(current($permid))) ? 'permid' : 'permsid';
        }

        $this->execute('channelgroupaddperm', ['cgid' => $cgid, $permident => $permid, 'permvalue' => $permvalue]);
    }

    /**
     * Removes a set of specified permissions from the channel group specified with $cgid. Multiple
     * permissions can be removed at once.
     *
     * @param  int $cgid
     * @param  int $permid
     * @return void
     */
    public function channelGroupPermRemove($cgid, $permid)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? 'permid' : 'permsid';
        } else {
            $permident = (is_numeric(current($permid))) ? 'permid' : 'permsid';
        }

        $this->execute('channelgroupdelperm', ['cgid' => $cgid, $permident => $permid]);
    }

    /**
     * Returns all the client and/or channel IDs currently assigned to channel groups. All three
     * parameters are optional so you're free to choose the most suitable combination for your
     * requirements.
     *
     * @param  int $cgid
     * @param  int $cid
     * @param  int $cldbid
     * @return array
     */
    public function channelGroupClientList($cgid = null, $cid = null, $cldbid = null)
    {
        if ($this['virtualserver_default_channel_group'] == $cgid) {
            return [];
        }

        return $this->execute('channelgroupclientlist', ['cgid' => $cgid, 'cid' => $cid, 'cldbid' => $cldbid])->toArray();
    }

    /**
     * Restores the default permission settings on the virtual server and returns a new initial
     * administrator privilege key.
     *
     * @return TeamSpeak3_Helper_String
     */
    public function permReset()
    {
        $token = $this->request('permreset')->toList();

        TeamSpeak3_Helper_Signal::getInstance()->emit('notifyTokencreated', $this, $token['token']);

        return $token['token'];
    }

    /**
     * Removes any assignment of the permission specified with $permid on the selected virtual server
     * and returns the number of removed assignments on success.
     *
     * @param  int $permid
     * @return int
     */
    public function permRemoveAny($permid)
    {
        $assignments = $this->permissionFind($permid);

        foreach ($assignments as $assignment) {
            switch ($assignment['t']) {
                case TeamSpeak3::PERM_TYPE_SERVERGROUP:
                    $this->serverGroupPermRemove($assignment['id1'], $assignment['p']);
                    break;

                case TeamSpeak3::PERM_TYPE_CLIENT:
                    $this->clientPermRemove($assignment['id2'], $assignment['p']);
                    break;

                case TeamSpeak3::PERM_TYPE_CHANNEL:
                    $this->channelPermRemove($assignment['id2'], $assignment['p']);
                    break;

                case TeamSpeak3::PERM_TYPE_CHANNELGROUP:
                    $this->channelGroupPermRemove($assignment['id1'], $assignment['p']);
                    break;

                case TeamSpeak3::PERM_TYPE_CHANNELCLIENT:
                    $this->channelClientPermRemove($assignment['id2'], $assignment['id1'], $assignment['p']);
                    break;

                default:
                    throw new TeamSpeak3_Adapter_ServerQuery_Exception('convert error', 0x604);
            }
        }

        return count($assignments);
    }

    /**
     * Initializes a file transfer upload. $clientftfid is an arbitrary ID to identify the file transfer on client-side.
     *
     * @param  int    $clientftfid
     * @param  int    $cid
     * @param  string $name
     * @param  int    $size
     * @param  string $cpw
     * @param  bool   $overwrite
     * @param  bool   $resume
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return array
     */
    public function transferInitUpload($clientftfid, $cid, $name, $size, $cpw = '', $overwrite = false, $resume = false)
    {
        $upload = $this->execute('ftinitupload', ['clientftfid' => $clientftfid, 'cid' => $cid, 'name' => $name, 'cpw' => $cpw, 'size' => $size, 'overwrite' => $overwrite, 'resume' => $resume])->toList();

        if (array_key_exists('status', $upload) && $upload['status'] != 0x00) {
            throw new TeamSpeak3_Adapter_ServerQuery_Exception($upload['msg'], $upload['status']);
        }

        $upload['cid']  = $cid;
        $upload['file'] = $name;

        if (!array_key_exists('ip', $upload) || $upload['ip']->startsWith('0.0.0.0')) {
            $upload['ip']   = $this->getParent()->getAdapterHost();
            $upload['host'] = $upload['ip'];
        } else {
            $upload['ip']   = $upload['ip']->section(',');
            $upload['host'] = $upload['ip'];
        }

        TeamSpeak3_Helper_Signal::getInstance()->emit('filetransferUploadInit', $upload['ftkey'], $upload);

        return $upload;
    }

    /**
     * Initializes a file transfer download. $clientftfid is an arbitrary ID to identify the file transfer on
     * client-side.
     *
     * @param  int    $clientftfid
     * @param  int    $cid
     * @param  string $name
     * @param  string $cpw
     * @param  int    $seekpos
     * @throws TeamSpeak3_Adapter_ServerQuery_Exception
     * @return array
     */
    public function transferInitDownload($clientftfid, $cid, $name, $cpw = '', $seekpos = 0)
    {
        $download = $this->execute('ftinitdownload', ['clientftfid' => $clientftfid, 'cid' => $cid, 'name' => $name, 'cpw' => $cpw, 'seekpos' => $seekpos])->toList();

        if (array_key_exists('status', $download) && $download['status'] != 0x00) {
            throw new TeamSpeak3_Adapter_ServerQuery_Exception($download['msg'], $download['status']);
        }

        $download['cid']  = $cid;
        $download['file'] = $name;

        if (!array_key_exists('ip', $download) || $download['ip']->startsWith('0.0.0.0')) {
            $download['ip']   = $this->getParent()->getAdapterHost();
            $download['host'] = $download['ip'];
        } else {
            $download['ip']   = $download['ip']->section(',');
            $download['host'] = $download['ip'];
        }

        TeamSpeak3_Helper_Signal::getInstance()->emit('filetransferDownloadInit', $download['ftkey'], $download);

        return $download;
    }

    /**
     * Displays a list of running file transfers on the selected virtual server. The output contains the path to
     * which a file is uploaded to, the current transfer rate in bytes per second, etc.
     *
     * @return array
     */
    public function transferList()
    {
        return $this->request('ftlist')->toAssocArray('serverftfid');
    }

    /**
     * Stops the running file transfer with server-side ID $serverftfid.
     *
     * @param  int  $serverftfid
     * @param  bool $delete
     * @return void
     */
    public function transferStop($serverftfid, $delete = false)
    {
        $this->execute('ftstop', ['serverftfid' => $serverftfid, 'delete' => $delete]);
    }

    /**
     * Downloads and returns the servers icon file content.
     *
     * @return TeamSpeak3_Helper_String
     */
    public function iconDownload()
    {
        if ($this->iconIsLocal('virtualserver_icon_id') || $this['virtualserver_icon_id'] == 0) {
            return;
        }

        $download = $this->transferInitDownload(rand(0x0000, 0xFFFF), 0, $this->iconGetName('virtualserver_icon_id'));
        $transfer = TeamSpeak3::factory('filetransfer://' . (strstr($download['host'], ':') !== false ? '[' . $download['host'] . ']' : $download['host']) . ':' . $download['port']);

        return $transfer->download($download['ftkey'], $download['size']);
    }

    /**
     * Uploads a given icon file content to the server and returns the ID of the icon.
     *
     * @param  string $data
     * @return int
     */
    public function iconUpload($data)
    {
        $crc  = crc32($data);
        $size = strlen($data);

        $upload   = $this->transferInitUpload(rand(0x0000, 0xFFFF), 0, '/icon_' . $crc, $size);
        $transfer = TeamSpeak3::factory('filetransfer://' . (strstr($upload['host'], ':') !== false ? '[' . $upload['host'] . ']' : $upload['host']) . ':' . $upload['port']);

        $transfer->upload($upload['ftkey'], $upload['seekpos'], $data);

        return $crc;
    }

    /**
     * Changes the virtual server configuration using given properties.
     *
     * @param  array $properties
     * @return void
     */
    public function modify(array $properties)
    {
        $this->execute('serveredit', $properties);
        $this->resetNodeInfo();
    }

    /**
     * Sends a text message to all clients on the virtual server.
     *
     * @param  string $msg
     * @return void
     */
    public function message($msg)
    {
        $this->execute('sendtextmessage', ['msg' => $msg, 'target' => $this->getId(), 'targetmode' => TeamSpeak3::TEXTMSG_SERVER]);
    }

    /**
     * Returns a list of offline messages you've received. The output contains the senders unique identifier,
     * the messages subject, etc.
     *
     * @return array
     */
    public function messageList()
    {
        return $this->request('messagelist')->toAssocArray('msgid');
    }

    /**
     * Sends an offline message to the client specified by $cluid.
     *
     * @param  string $cluid
     * @param  string $subject
     * @param  string $message
     * @return void
     */
    public function messageCreate($cluid, $subject, $message)
    {
        $this->execute('messageadd', ['cluid' => $cluid, 'subject' => $subject, 'message' => $message]);
    }

    /**
     * Deletes an existing offline message with ID $msgid from your inbox.
     *
     * @param  int $msgid
     * @return void
     */
    public function messageDelete($msgid)
    {
        $this->execute('messagedel', ['msgid' => $msgid]);
    }

    /**
     * Returns an existing offline message with ID $msgid from your inbox.
     *
     * @param  int  $msgid
     * @param  bool $flag_read
     * @return array
     */
    public function messageRead($msgid, $flag_read = true)
    {
        $msg = $this->execute('messageget', ['msgid' => $msgid])->toList();

        if ($flag_read) {
            $this->execute('messageget', ['msgid' => $msgid, 'flag' => $flag_read]);
        }

        return $msg;
    }

    /**
     * Creates and returns snapshot data for the selected virtual server.
     *
     * @param  string $mode
     * @return string
     */
    public function snapshotCreate($mode = TeamSpeak3::SNAPSHOT_STRING)
    {
        $snapshot = $this->request('serversnapshotcreate')->toString(false);

        switch ($mode) {
            case TeamSpeak3::SNAPSHOT_BASE64:
                return $snapshot->toBase64();
                break;

            case TeamSpeak3::SNAPSHOT_HEXDEC:
                return $snapshot->toHex();
                break;

            default:
                return (string) $snapshot;
                break;
        }
    }

    /**
     * Deploys snapshot data on the selected virtual server. If no virtual server is selected (ID 0),
     * the data will be used to create a new virtual server from scratch.
     *
     * @param  string $data
     * @param  string $mode
     * @return array
     */
    public function snapshotDeploy($data, $mode = TeamSpeak3::SNAPSHOT_STRING)
    {
        switch ($mode) {
            case TeamSpeak3::SNAPSHOT_BASE64:
                $data = TeamSpeak3_Helper_String::fromBase64($data);
                break;

            case TeamSpeak3::SNAPSHOT_HEXDEC:
                $data = TeamSpeak3_Helper_String::fromHex($data);
                break;

            default:
                $data = TeamSpeak3_Helper_String::factory($data);
                break;
        }

        $detail = $this->request('serversnapshotdeploy ' . $data)->toList();

        if (array_key_exists('sid', $detail)) {
            TeamSpeak3_Helper_Signal::getInstance()->emit('notifyServercreated', $this->getParent(), $detail['sid']);
        }

        return $detail;
    }

    /**
     * Registers for a specified category of events on a virtual server to receive notification
     * messages. Depending on the notifications you've registered for, the server will send you
     * a message on every event.
     *
     * @param  string $event
     * @param  int    $id
     * @return void
     */
    public function notifyRegister($event, $id = 0)
    {
        $this->execute('servernotifyregister', ['event' => $event, 'id' => $id]);
    }

    /**
     * Unregisters all events previously registered with servernotifyregister so you will no
     * longer receive notification messages.
     *
     * @return void
     */
    public function notifyUnregister()
    {
        $this->request('servernotifyunregister');
    }

    /**
     * Alias for privilegeKeyList().
     *
     * @deprecated
     * @param mixed $translate
     */
    public function tokenList($translate = false)
    {
        return $this->privilegeKeyList();
    }

    /**
     * Returns a list of privilege keys (tokens) available. If $resolve is set to TRUE the values
     * of token_id1 and token_id2 will be translated into the appropriate group and/or channel
     * names.
     *
     * @param  bool $resolve
     * @return array
     */
    public function privilegeKeyList($resolve = false)
    {
        $tokens = $this->request('privilegekeylist')->toAssocArray('token');

        if ($resolve) {
            foreach ($tokens as $token => $array) {
                $func = $array['token_type'] ? 'channelGroupGetById' : 'serverGroupGetById';

                try {
                    $tokens[$token]['token_id1'] = $this->$func($array['token_id1'])->name;
                } catch (Exception $e) {
                    /* ERROR_channel_invalid_id */
                    if ($e->getCode() != 0xA00) {
                        throw $e;
                    }
                }

                try {
                    if ($array['token_type']) {
                        $tokens[$token]['token_id2'] = $this->channelGetById($array['token_id2'])->getPathway();
                    }
                } catch (Exception $e) {
                    /* ERROR_permission_invalid_group_id */
                    if ($e->getCode() != 0x300) {
                        throw $e;
                    }
                }
            }
        }

        return $tokens;
    }

    /**
     * Alias for privilegeKeyCreate().
     *
     * @deprecated
     * @param mixed      $type
     * @param mixed      $id1
     * @param mixed      $id2
     * @param null|mixed $description
     * @param null|mixed $customset
     */
    public function tokenCreate($type, $id1, $id2 = 0, $description = null, $customset = null)
    {
        return $this->privilegeKeyCreate($type, $id1, $id2, $description, $customset);
    }

    /**
     * Creates a new privilege key (token) and returns the key.
     *
     * @param  int    $type
     * @param  int    $id1
     * @param  int    $id2
     * @param  string $description
     * @param  string $customset
     * @return TeamSpeak3_Helper_String
     */
    public function privilegeKeyCreate($type, $id1, $id2 = 0, $description = null, $customset = null)
    {
        $token = $this->execute('privilegekeyadd', ['tokentype' => $type, 'tokenid1' => $id1, 'tokenid2' => $id2, 'tokendescription' => $description, 'tokencustomset' => $customset])->toList();

        TeamSpeak3_Helper_Signal::getInstance()->emit('notifyTokencreated', $this, $token['token']);

        return $token['token'];
    }

    /**
     * Alias for privilegeKeyDelete().
     *
     * @deprecated
     * @param mixed $token
     */
    public function tokenDelete($token)
    {
        $this->privilegeKeyDelete($token);
    }

    /**
     * Deletes a token specified by key $token.
     *
     * @param  string $token
     * @return void
     */
    public function privilegeKeyDelete($token)
    {
        $this->execute('privilegekeydelete', ['token' => $token]);
    }

    /**
     * Alias for privilegeKeyUse().
     *
     * @deprecated
     * @param mixed $token
     */
    public function tokenUse($token)
    {
        $this->privilegeKeyUse($token);
    }

    /**
     * Use a token key gain access to a server or channel group. Please note that the server will
     * automatically delete the token after it has been used.
     *
     * @param  string $token
     * @return void
     */
    public function privilegeKeyUse($token)
    {
        $this->execute('privilegekeyuse', ['token' => $token]);
    }

    /**
     * Returns a list of custom client properties specified by $ident.
     *
     * @param  string $ident
     * @param  string $pattern
     * @return array
     */
    public function customSearch($ident, $pattern = '%')
    {
        return $this->execute('customsearch', ['ident' => $ident, 'pattern' => $pattern])->toArray();
    }

    /**
     * Returns a list of custom properties for the client specified by $cldbid.
     *
     * @param  int $cldbid
     * @return array
     */
    public function customInfo($cldbid)
    {
        return $this->execute('custominfo', ['cldbid' => $cldbid])->toArray();
    }

    /**
     * Returns a list of active bans on the selected virtual server.
     *
     * @return array
     */
    public function banList()
    {
        return $this->request('banlist')->toAssocArray('banid');
    }

    /**
     * Deletes all active ban rules from the server.
     *
     * @return void
     */
    public function banListClear()
    {
        $this->request('bandelall');
    }

    /**
     * Adds a new ban rule on the selected virtual server. All parameters are optional but at least one
     * of the following rules must be set: ip, name, or uid.
     *
     * @param  array  $rules
     * @param  int    $timeseconds
     * @param  string $reason
     * @return int
     */
    public function banCreate(array $rules, $timeseconds = null, $reason = null)
    {
        $rules['time']      = $timeseconds;
        $rules['banreason'] = $reason;

        $banid = $this->execute('banadd', $rules)->toList();

        return $banid['banid'];
    }

    /**
     * Deletes the specified ban rule from the server.
     *
     * @param  int $banid
     * @return void
     */
    public function banDelete($banid)
    {
        $this->execute('bandel', ['banid' => $banid]);
    }

    /**
     * Returns a list of complaints on the selected virtual server. If $tcldbid is specified, only
     * complaints about the targeted client will be shown.
     *
     * @param  int $tcldbid
     * @return array
     */
    public function complaintList($tcldbid = null)
    {
        return $this->execute('complainlist', ['tcldbid' => $tcldbid])->toArray();
    }

    /**
     * Deletes all active complaints about the client with database ID $tcldbid from the server.
     *
     * @param  int $tcldbid
     * @return void
     */
    public function complaintListClear($tcldbid)
    {
        $this->execute('complaindelall', ['tcldbid' => $tcldbid]);
    }

    /**
     * Submits a complaint about the client with database ID $tcldbid to the server.
     *
     * @param  int    $tcldbid
     * @param  string $message
     * @return void
     */
    public function complaintCreate($tcldbid, $message)
    {
        $this->execute('complainadd', ['tcldbid' => $tcldbid, 'message' => $message]);
    }

    /**
     * Deletes the complaint about the client with ID $tcldbid submitted by the client with ID $fcldbid from the server.
     *
     * @param  int $tcldbid
     * @param  int $fcldbid
     * @return void
     */
    public function complaintDelete($tcldbid, $fcldbid)
    {
        $this->execute('complaindel', ['tcldbid' => $tcldbid, 'fcldbid' => $fcldbid]);
    }

    /**
     * Returns a list of temporary server passwords.
     *
     * @param  bool $resolve
     * @return array
     */
    public function tempPasswordList($resolve = false)
    {
        $passwords = $this->request('servertemppasswordlist')->toAssocArray('pw_clear');

        if ($resolve) {
            foreach ($passwords as $password => $array) {
                try {
                    $channel = $this->channelGetById($array['tcid']);

                    $passwords[$password]['tcname'] = $channel->toString();
                    $passwords[$password]['tcpath'] = $channel->getPathway();
                } catch (Exception $e) {
                    /* ERROR_channel_invalid_id */
                    if ($e->getCode() != 0xA00) {
                        throw $e;
                    }
                }
            }
        }

        return $passwords;
    }

    /**
     * Sets a new temporary server password specified with $pw. The temporary password will be
     * valid for the number of seconds specified with $duration. The client connecting with this
     * password will automatically join the channel specified with $tcid. If tcid is set to 0,
     * the client will join the default channel.
     *
     * @param  string $pw
     * @param  int    $duration
     * @param  int    $tcid
     * @param  string $tcpw
     * @param  string $desc
     * @return void
     */
    public function tempPasswordCreate($pw, $duration, $tcid = 0, $tcpw = '', $desc = '')
    {
        $this->execute('servertemppasswordadd', ['pw' => $pw, 'duration' => $duration, 'tcid' => $tcid, 'tcpw' => $tcpw, 'desc' => $desc]);
    }

    /**
     * Deletes the temporary server password specified with $pw.
     *
     * @param  string $pw
     * @return void
     */
    public function tempPasswordDelete($pw)
    {
        $this->execute('servertemppassworddel', ['pw' => $pw]);
    }

    /**
     * Displays a specified number of entries (1-100) from the servers log.
     *
     * @param  int  $lines
     * @param  int  $begin_pos
     * @param  bool $reverse
     * @param  bool $instance
     * @return array
     */
    public function logView($lines = 30, $begin_pos = null, $reverse = null, $instance = null)
    {
        return $this->execute('logview', ['lines' => $lines, 'begin_pos' => $begin_pos, 'instance' => $instance, 'reverse' => $reverse])->toArray();
    }

    /**
     * Writes a custom entry into the virtual server log.
     *
     * @param  string $logmsg
     * @param  int    $loglevel
     * @return void
     */
    public function logAdd($logmsg, $loglevel = TeamSpeak3::LOGLEVEL_INFO)
    {
        $this->execute('logadd', ['logmsg' => $logmsg, 'loglevel' => $loglevel]);
    }

    /**
     * Returns detailed connection information of the virtual server.
     *
     * @return array
     */
    public function connectionInfo()
    {
        return $this->request('serverrequestconnectioninfo')->toList();
    }

    /**
     * Deletes the virtual server.
     *
     * @return void
     */
    public function delete()
    {
        $this->getParent()->serverDelete($this->getId());
    }

    /**
     * Starts the virtual server.
     *
     * @return void
     */
    public function start()
    {
        $this->getParent()->serverStart($this->getId());
    }

    /**
     * Stops the virtual server.
     *
     * @return void
     */
    public function stop()
    {
        $this->getParent()->serverStop($this->getId());
    }

    /**
     * Sends a plugin command to all clients connected to the server.
     *
     * @param  string $plugin
     * @param  string $data
     * @return void
     */
    public function sendPluginCmd($plugin, $data)
    {
        $this->execute('plugincmd', ['name' => $plugin, 'data' => $data, 'targetmode' => TeamSpeak3::PLUGINCMD_SERVER]);
    }

    /**
     * Changes the properties of your own client connection.
     *
     * @param  array $properties
     * @return void
     */
    public function selfUpdate(array $properties)
    {
        $this->execute('clientupdate', $properties);

        foreach ($properties as $ident => $value) {
            $this->whoamiSet($ident, $value);
        }
    }

    /**
     * Updates your own ServerQuery login credentials using a specified username. The password
     * will be auto-generated.
     *
     * @param  string $username
     * @return TeamSpeak3_Helper_String
     */
    public function selfUpdateLogin($username)
    {
        $password = $this->execute('clientsetserverquerylogin', ['client_login_name' => $username])->toList();

        return $password['client_login_password'];
    }

    /**
     * Returns an array containing the permission overview of your own client.
     *
     * @return array
     */
    public function selfPermOverview()
    {
        return $this->execute('permoverview', ['cldbid' => $this->whoamiGet('client_database_id'), 'cid' => $this->whoamiGet('client_channel_id'), 'permid' => 0])->toArray();
    }

    /**
     * @ignore
     */
    protected function fetchNodeList()
    {
        $this->nodeList = [];

        foreach ($this->channelList() as $channel) {
            if ($channel['pid'] == 0) {
                $this->nodeList[] = $channel;
            }
        }
    }

    /**
     * @ignore
     */
    protected function fetchNodeInfo()
    {
        $this->nodeInfo = array_merge($this->nodeInfo, $this->request('serverinfo')->toList());
    }

    /**
     * Internal callback funtion for sorting of client objects.
     *
     * @param  TeamSpeak3_Node_Client $a
     * @param  TeamSpeak3_Node_Client $b
     * @return int
     */
    protected static function sortClientList(TeamSpeak3_Node_Client $a, TeamSpeak3_Node_Client $b)
    {
        if (get_class($a) != get_class($b)) {
            return 0;

            /* workaround for PHP bug #50688 */
            throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid parameter', 0x602);
        }

        if (!$a instanceof TeamSpeak3_Node_Client) {
            return 0;

            /* workaround for PHP bug #50688 */
            throw new TeamSpeak3_Adapter_ServerQuery_Exception('convert error', 0x604);
        }

        if ($a->getProperty('client_talk_power', 0) != $b->getProperty('client_talk_power', 0)) {
            return ($a->getProperty('client_talk_power', 0) > $b->getProperty('client_talk_power', 0)) ? -1 : 1;
        }

        if ($a->getProperty('client_is_talker', 0) != $b->getProperty('client_is_talker', 0)) {
            return ($a->getProperty('client_is_talker', 0) > $b->getProperty('client_is_talker', 0)) ? -1 : 1;
        }

        return strcmp(strtolower($a['client_nickname']), strtolower($b['client_nickname']));
    }

    /**
     * Internal callback funtion for sorting of group objects.
     *
     * @param  TeamSpeak3_Node_Abstract $a
     * @param  TeamSpeak3_Node_Abstract $b
     * @return int
     */
    public static function sortGroupList(TeamSpeak3_Node_Abstract $a, TeamSpeak3_Node_Abstract $b)
    {
        if (get_class($a) != get_class($b)) {
            return 0;

            /* workaround for PHP bug #50688 */
            throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid parameter', 0x602);
        }

        if (!$a instanceof TeamSpeak3_Node_Servergroup && !$a instanceof TeamSpeak3_Node_Channelgroup) {
            return 0;

            /* workaround for PHP bug #50688 */
            throw new TeamSpeak3_Adapter_ServerQuery_Exception('convert error', 0x604);
        }

        if ($a->getProperty('sortid', 0) != $b->getProperty('sortid', 0) && $a->getProperty('sortid', 0) != 0 && $b->getProperty('sortid', 0) != 0) {
            return ($a->getProperty('sortid', 0) < $b->getProperty('sortid', 0)) ? -1 : 1;
        }

        return ($a->getId() < $b->getId()) ? -1 : 1;
    }

    /**
     * Internal callback funtion for sorting of file list items.
     *
     * @param  array $a
     * @param  array $b
     * @return int
     */
    protected static function sortFileList(array $a, array $b)
    {
        if (!array_key_exists('src', $a) || !array_key_exists('src', $b) || !array_key_exists('type', $a) || !array_key_exists('type', $b)) {
            return 0;

            throw new TeamSpeak3_Adapter_ServerQuery_Exception('invalid parameter', 0x602);
        }

        if ($a['type'] != $b['type']) {
            return ($a['type'] < $b['type']) ? -1 : 1;
        }

        return strcmp(strtolower($a['src']), strtolower($b['src']));
    }

    /**
     * Returns TRUE if the virtual server is online.
     *
     * @return bool
     */
    public function isOnline()
    {
        return ($this['virtualserver_status'] == 'online') ? true : false;
    }

    /**
     * Returns TRUE if the virtual server is offline.
     *
     * @return bool
     */
    public function isOffline()
    {
        return ($this['virtualserver_status'] == 'offline') ? true : false;
    }

    /**
     * Returns a unique identifier for the node which can be used as a HTML property.
     *
     * @return string
     */
    public function getUniqueId()
    {
        return $this->getParent()->getUniqueId() . '_s' . $this->getId();
    }

    /**
     * Returns the name of a possible icon to display the node object.
     *
     * @return string
     */
    public function getIcon()
    {
        if ($this['virtualserver_clientsonline'] - $this['virtualserver_queryclientsonline'] >= $this['virtualserver_maxclients']) {
            return 'server_full';
        } elseif ($this['virtualserver_flag_password']) {
            return 'server_pass';
        } else {
            return 'server_open';
        }
    }

    /**
     * Returns a symbol representing the node.
     *
     * @return string
     */
    public function getSymbol()
    {
        return '$';
    }

    /**
     * Returns a string representation of this node.
     *
     * @return string
     */
    public function __toString()
    {
        return (string) $this['virtualserver_name'];
    }
}
