<?php
/**
* класс для сохранеия статистики проходов по сайту
*/
class SiteStatistic
{
    /* в качестве хранилища используеться мемкеш */
    const MEMCACHE_STORE_TYPE = 1;

    /* в качестве хранилища используеться mysql */
    const MYSQL_STORE_TYPE = 2;

    /* в качестве хранилища используеться file */
    const FILE_STORE_TYPE = 3;

    /**
    * название таблицы в к-ой будет сохраняться статистика
    *
    * @var string
    */
    private static $_mysqlStatisticTable = 's_google_stat';

    /**
    * максимальное кол-во ключей, по к-ым будет сохраняться статиски в кеше
    *
    * @var int
    */
    private static $_cacheKeyMaxCount = 10;
    /**
    * префикс для ключа кеша
    *
    * @var String
    */
    private static $_cacheKeyPrefix = 'site_stat';

    /**
    * время жизни кеша
    *
    * @var int
    */
    private static $_cacheExpireTime = 300;

    /**
    * абсолютный путь до файла, в к-ом будет сохраняться статистика
    *
    * @var String
    */
    private static $_fileAbsolutePath = '';

    /**
    * массив полей таблицы, к-ая используеться для сохранения статистики
    *
    * @var array
    */
    private static $_tableFieldList = array();
    /**
    * метод сохраняет переданную информацию о статиске
    *
    * @param int $typeStore тип хранилища для статики
    * @param array $statInfo массив с информацией о статистике, имеющий след. поля :
    *  Array('PageUrl', 'ExecuteTime', 'DetailInfo', 'CreateDate', 'RemoteIp')
    *
    * @return bool
    */
    static public function saveInfo( $typeStore, $statInfo )
    {
        switch ($typeStore)
        {
            /* сохранем данные в мемкеше */
            case self::MEMCACHE_STORE_TYPE :
                global $oCache;
                self::_saveInfoToMemcache($statInfo, $oCache);
            break;

            /*сохраняем данные в мускуле*/
            case self::MYSQL_STORE_TYPE :
                global $DB;
                self::_saveInfoToMysql($statInfo, $DB);
            break;

            case self::FILE_STORE_TYPE:
                self::_saveInfoToFile($statInfo);
            break;
        }

        return true;

    }
    /**
    * метод для сохранения статистики в мемкеше
    *
    * @param array $statInfo  массив с инфомрацией о статистике
    * @param GenericCache $memcacheObject объект класса для работы с мемкешом
    *
    * @return bool
    */
    static private function _saveInfoToMemcache ( $statInfo, $memcacheObject )
    {
        // проверяем инстанцирован ли переданный объект от классов-клиентов мемкеша

        if ( !is_object($memcacheObject) || get_class($memcacheObject) != 'GenericCache')
        {
            throw new SiteStatistic_Exception('It is not memcache object');
        }

        // проверяем валидность переданных данных
        if ( $statInfo = self::_validateStatInfo($statInfo) )
        {
            // статистика в мемкеше будет сохраняться по нескольким ключам
            // таким образом будет решена проблема потери даннвх при одновреаенном вызове хранилища из мемкеша
            $cacheUID = self::$_cacheKeyPrefix . rand(1, self::$_cacheKeyMaxCount);

            if ( false === ($statInfoList = $memcacheObject->get($cacheUID)))
            {
                $statInfoList = array();
            }
            $statInfoList[] = $statInfo;

            if ( false === $memcacheObject->set($statInfoList, $cacheUID, self::$_cacheExpireTime) )
            {
                throw new SiteStatistic_Exception('can not save data in cache');
            }
        }
        return true;
    }
    /**
    *
    * метод сохраняет статистику в mysql
    *
    * @param array $statInfoList коллекция массивов с данными по статистике
    * @param GenericDatabase $dbAdapter адаптер для работы с Mysql
    *
    * @return bool
    */
    static private function _saveInfoToMysql ( $statInfoList, $dbAdapter )
    {
        // проверяем инстанцирован ли переданный объект от классов-клиентов мемкеша
        if ( !is_object($dbAdapter) || get_class($dbAdapter) != 'GenericDatabase')
        {
            throw new SiteStatistic_Exception('It is not valid db adapter');
        }

        // проверяем валидность переданной коллекции со статистикой
        if ( empty($statInfoList) || isset($statInfoList['PageUrl']) )
        {
            throw new SiteStatistic_Exception('List of stat info is not valid! ');
        }
        // получаем список полей у таблицы, к-ая используеться для сохранения статистики
        if ( empty(self::$_tableFieldList) )
        {

            self::$_tableFieldList = self::_getTableFieldList( self::$_mysqlStatisticTable, $dbAdapter );
        }
        $tableFields = self::$_tableFieldList;
        if ( empty($tableFields) )
        {
            throw new SiteStatistic_Exception('tableFields is empty!');
        }

        // формируем Sql-запрос для сохрананения статистики
        $sql = 'INSERT INTO `' . self::$_mysqlStatisticTable . '` (' . implode(',', $tableFields) . ') VALUES ';
        $statValuesList = array();
        foreach ( $statInfoList as $statInfo )
        {
            $statValues = array();
            // пробегаемся по полям из таблицы и находим соотвествие с индексами в массиве с данными по стате
            foreach ( $tableFields as $fieldName )
            {
                if ( !isset($statInfo[$fieldName]) )
                {
                    throw new SiteStatistic_Exception('Not found fieldName "' . $fieldName .'" in statInfo');
                }
                $statValues[] = sprintf('"%s"', mysql_escape_string($statInfo[$fieldName]) );
            }
            $statValuesList[] = '(' . implode(',', $statValues) . ')' ;
        }
        $sql .= implode(',', $statValuesList);

        // выполняем запрос на вставку группы данных по статистике
        $dbAdapter->Query($sql);

        return true;
    }
    /**
    * метод сохраняет статистику в файле на сервере
    *
    * @param array $statInfo   массив с инфомрацией о статистике
    *
    * @return bool
    */
    static private function _saveInfoToFile ( $statInfo )
    {
        if ( file_exists(self::$_fileAbsolutePath) && self::_validateStatInfo($statInfo) )
        {
            $fp = fopen(self::$_fileAbsolutePath, 'a+');
            $sStr = sprintf ('%s page %s main_exec_time %s remote_ip: %s',
                                    date('d.m.Y H:i:s'),
                                    $statInfo['PageUrl'],
                                    $statInfo['ExecuteTime'],
                                    $statInfo['RemoteIp']
                                    );
            $sStr .= "\n";
            if ($statInfo['ExecuteTime'] > 1)
            {
               $sStr .=  "Detail: \n";
               foreach ($APPLICATION->arSetTimer as $sIndex => $sVal)
               {
                   $sStr .= $sIndex . ": " . $sVal ."\n";
               }

            }
            fputs($fp, $sStr);
            fclose($fp);
        }

        return false;
    }
    /**
    * метод возращает список полей у переданной таблицы
    *
    * @param string $tableName название таблицы
    * @param GenericDatabase $dbAdapter mysql адаптер
    *
    * @return array
    */
    static private function _getTableFieldList ( $tableName, $dbAdapter )
    {
        $result = array();
        $columnDbRes = $dbAdapter->Query('SHOW COLUMNS FROM ' . $tableName);
        while ( $columnData = $columnDbRes->Fetch() )
        {
            if ( $columnData['Extra'] != 'auto_increment' )
            {
                $result[] = $columnData['Field'];
            }
        }

        return $result;
    }
    /**
    * метод изменяет или возвращает название таблицы, к-ая используеться для сохранения статистики
    *
    * @param string $tableName навзание таблицы
    *
    * @return bool
    */
    static public function mysqlTableForStat ( $tableName = null )
    {
        if ( is_null($tableName) )
        {
            return self::$_mysqlStatisticTable;
        }

        self::$_mysqlStatisticTable = $tableName;

        return true;

    }
    /**
    * возвращаем или изменяем макимальное кол-во ключей для хранения данных в мемкеше
    *
    * @param int $maxCount число ключей
    *
    * @return bool
    */
    static public function cacheKeyMaxCount ( $maxCount = null )
    {
        if ( is_null($maxCount) )
        {
            return self::$_cacheKeyMaxCount;
        }

        self::$_cacheKeyMaxCount = $maxCount;

        return true;
    }
    /**
    * возвращаем или изменяем префикс для ключа, по к-ому будут сохраняться данные в кеше
    *
    * @param string $keyPrefix префикс ключа
    *
    * @return bool
    */
    static public function cacheKeyPrefix ( $keyPrefix = null )
    {
        if ( is_null($keyPrefix) )
        {
            return self::$_cacheKeyPrefix;
        }

        self::$_cacheKeyPrefix = $keyPrefix;

        return true;

    }
    /**
    * возвращаем или изменяем абсолютный путь для файла со статискийо
    *
    * @param string $absolutePath абсолютный путь
    *
    * @return bool
    */
    static public function fileAbsolutePath ( $absolutePath = null )
    {
        if ( is_null($absolutePath) )
        {
            return self::$_fileAbsolutePath;
        }

        self::$_fileAbsolutePath = $absolutePath;

        return true;
    }
    /**
    * возвращаем или устаналиваем время жизни кеша
    *
    * @param int $time
    */
    static public function cacheExpireTime ( $time = null )
    {
        if ( is_null($time) )
        {
            return self::$_cacheExpireTime;
        }

        self::$_cacheExpireTime = $time;

        return true;

    }
    /**
    * проверяем валидность переданной информации по статистике
    *
    * @param array $statInfo массив с инфомрацией о статистике
    *
    * @return bool
    */
    static private function _validateStatInfo ( $statInfo )
    {
        if ( !isset($statInfo['PageUrl']) || empty($statInfo['PageUrl']) )
        {
            throw new SiteStatistic_Exception('Incorrect field: PageUrl');
        }

        if ( !isset($statInfo['ExecuteTime']) || !(int) ($statInfo['PageUrl'] + 1) )
        {
            throw new SiteStatistic_Exception('Incorrect field: ExecuteTime');
        }

        if ( !isset($statInfo['DetailInfo']) )
        {
            throw new SiteStatistic_Exception('Not found field: ExecuteTime');
        }

        if ( !isset($statInfo['RemoteIp']) || !preg_match('/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/', $statInfo['RemoteIp']) )
        {
            throw new SiteStatistic_Exception('Incorrect field: RemoteIp');
        }
        $statInfo['RemoteIp'] = self::_ip2int($statInfo['RemoteIp']);
        return $statInfo;
    }
    /**
    * переводим ip в целочисленный вид
    *
    * @param string $ip
    *
    * @return int
    */
    static private function _ip2int($ip)
    {
        $a=explode(".",$ip);
        return $a[0]*256*256*256+$a[1]*256*256+$a[2]*256+$a[3];
    }


}

class SiteStatistic_Exception extends Exception {}
?>