<?php

/**
 *      [Discuz!] (C)2001-2099 Comsenz Inc.
 *      This is NOT a freeware, use is subject to license terms
 *
 *      $Id: class_core.php 33982 2013-09-12 06:36:35Z hypowang $
 */

// 设置错误报告级别为显示所有错误
error_reporting(E_ALL);

// 定义常量，表示当前脚本在 Discuz! 环境中运行
define('IN_DISCUZ', true);

// 定义 Discuz! 根目录路径，去掉路径末尾的 12 个字符（通常是 '/source/class'）
define('DISCUZ_ROOT', substr(dirname(__FILE__), 0, -12));

// 定义是否开启核心调试模式
define('DISCUZ_CORE_DEBUG', false);

// 定义是否支持表扩展
define('DISCUZ_TABLE_EXTENDABLE', false);

// 设置全局异常处理函数为 core::handleException
set_exception_handler(array('core', 'handleException'));

// 如果开启调试模式，设置错误处理函数和脚本结束时的处理函数
if(DISCUZ_CORE_DEBUG) {
	set_error_handler(array('core', 'handleError'));
	register_shutdown_function(array('core', 'handleShutdown'));
}

// 注册自动加载函数 core::autoload
spl_autoload_register(array('core', 'autoload'));

// 创建应用程序实例
C::creatapp();

/**
 * 核心类 core
 * 负责 Discuz! 的核心功能，包括类加载、对象管理、异常处理等
 */
class core
{
	// 静态变量，用于存储表对象
	private static $_tables;

	// 静态变量，用于存储已加载的文件
	private static $_imports;

	// 静态变量，存储应用程序实例
	private static $_app;

	// 静态变量，存储内存管理对象
	private static $_memory;

	/**
	 * 获取应用程序实例
	 * @return object 应用程序实例
	 */
	public static function app() {
		return self::$_app;
	}

	/**
	 * 创建应用程序实例
	 * @return object 应用程序实例
	 */
	public static function creatapp() {
		if(!is_object(self::$_app)) {
			self::$_app = discuz_application::instance();
		}
		return self::$_app;
	}

	/**
	 * 获取表对象
	 * @param string $name 表名
	 * @return object 表对象
	 */
	public static function t($name) {
		return self::_make_obj($name, 'table', DISCUZ_TABLE_EXTENDABLE);
	}

	/**
	 * 获取模型对象
	 * @param string $name 模型名
	 * @return object 模型对象
	 */
	public static function m($name) {
		$args = array();
		if(func_num_args() > 1) {
			$args = func_get_args();
			unset($args[0]);
		}
		return self::_make_obj($name, 'model', true, $args);
	}

	/**
	 * 创建对象
	 * @param string $name 对象名
	 * @param string $type 对象类型（table 或 model）
	 * @param bool $extendable 是否支持扩展
	 * @param array $p 构造函数参数
	 * @return object 创建的对象
	 */
	protected static function _make_obj($name, $type, $extendable = false, $p = array()) {
		$pluginid = null;
		// 如果对象名以 # 开头，表示是插件对象
		if($name[0] === '#') {
			list(, $pluginid, $name) = explode('#', $name);
		}
		$cname = $type.'_'.$name;
		// 如果对象未创建，则创建对象
		if(!isset(self::$_tables[$cname])) {
			// 如果类未加载，则加载类文件
			if(!class_exists($cname, false)) {
				self::import(($pluginid ? 'plugin/'.$pluginid : 'class').'/'.$type.'/'.$name);
			}
			// 如果支持扩展，则使用容器对象
			if($extendable) {
				self::$_tables[$cname] = new discuz_container();
				switch (count($p)) {
					case 0:	self::$_tables[$cname]->obj = new $cname();break;
					case 1:	self::$_tables[$cname]->obj = new $cname($p[1]);break;
					case 2:	self::$_tables[$cname]->obj = new $cname($p[1], $p[2]);break;
					case 3:	self::$_tables[$cname]->obj = new $cname($p[1], $p[2], $p[3]);break;
					case 4:	self::$_tables[$cname]->obj = new $cname($p[1], $p[2], $p[3], $p[4]);break;
					case 5:	self::$_tables[$cname]->obj = new $cname($p[1], $p[2], $p[3], $p[4], $p[5]);break;
					default: $ref = new ReflectionClass($cname);self::$_tables[$cname]->obj = $ref->newInstanceArgs($p);unset($ref);break;
				}
			} else {
				// 如果不支持扩展，则直接创建对象
				self::$_tables[$cname] = new $cname();
			}
		}
		return self::$_tables[$cname];
	}

	/**
	 * 获取内存管理对象
	 * @return object 内存管理对象
	 */
	public static function memory() {
		if(!self::$_memory) {
			self::$_memory = new discuz_memory();
			self::$_memory->init(self::app()->config['memory']);
		}
		return self::$_memory;
	}

	/**
	 * 加载类文件
	 * @param string $name 类名
	 * @param string $folder 文件夹
	 * @param bool $force 是否强制加载
	 * @return bool 是否加载成功
	 * @throws Exception 如果文件不存在且强制加载，则抛出异常
	 */
	public static function import($name, $folder = '', $force = true) {
		$key = $folder.$name;
		// 如果文件未加载，则加载文件
		if(!isset(self::$_imports[$key])) {
			$path = DISCUZ_ROOT.'/source/'.$folder;
			// 处理类文件路径
			if(strpos($name, '/') !== false) {
				$pre = basename(dirname($name));
				$filename = dirname($name).'/'.$pre.'_'.basename($name).'.php';
			} else {
				$filename = $name.'.php';
			}

			// 如果文件存在，则加载文件
			if(is_file($path.'/'.$filename)) {
				include $path.'/'.$filename;
				self::$_imports[$key] = true;

				return true;
			} elseif(!$force) {
				// 如果文件不存在且不强制加载，则返回 false
				return false;
			} else {
				// 如果文件不存在且强制加载，则抛出异常
				throw new Exception('Oops! System file lost: '.$filename);
			}
		}
		return true;
	}

	/**
	 * 异常处理函数
	 * @param Exception $exception 异常对象
	 */
	public static function handleException($exception) {
		discuz_error::exception_error($exception);
	}

	/**
	 * 错误处理函数
	 * @param int $errno 错误级别
	 * @param string $errstr 错误信息
	 * @param string $errfile 错误文件
	 * @param int $errline 错误行号
	 */
	public static function handleError($errno, $errstr, $errfile, $errline) {
		if($errno & DISCUZ_CORE_DEBUG) {
			discuz_error::system_error($errstr, false, true, false);
		}
	}

	/**
	 * 脚本结束时的处理函数
	 */
	public static function handleShutdown() {
		if(($error = error_get_last()) && $error['type'] & DISCUZ_CORE_DEBUG) {
			discuz_error::system_error($error['message'], false, true, false);
		}
	}

	/**
	 * 自动加载函数
	 * @param string $class 类名
	 * @return bool 是否加载成功
	 */
	public static function autoload($class) {
		$class = strtolower($class);
		// 根据类名生成文件路径
		if(strpos($class, '_') !== false) {
			list($folder) = explode('_', $class);
			$file = 'class/'.$folder.'/'.substr($class, strlen($folder) + 1);
		} else {
			$file = 'class/'.$class;
		}

		try {
			// 加载类文件
			self::import($file);
			return true;
		} catch (Exception $exc) {
			// 如果加载失败，则检查是否是 class_exists 调用
			$trace = $exc->getTrace();
			foreach ($trace as $log) {
				if(empty($log['class']) && $log['function'] == 'class_exists') {
					return false;
				}
			}
			// 如果不是 class_exists 调用，则抛出异常
			discuz_error::exception_error($exc);
		}
	}

	/**
	 * 开始性能分析
	 * @param string $name 分析名称
	 */
	public static function analysisStart($name){
		$key = 'other';
		// 如果名称以 # 开头，则表示是插件分析
		if($name[0] === '#') {
			list(, $key, $name) = explode('#', $name);
		}
		// 初始化分析数据
		if(!isset($_ENV['analysis'])) {
			$_ENV['analysis'] = array();
		}
		if(!isset($_ENV['analysis'][$key])) {
			$_ENV['analysis'][$key] = array();
			$_ENV['analysis'][$key]['sum'] = 0;
		}
		// 记录开始时间、内存使用情况
		$_ENV['analysis'][$key][$name]['start'] = microtime(TRUE);
		$_ENV['analysis'][$key][$name]['start_memory_get_usage'] = memory_get_usage();
		$_ENV['analysis'][$key][$name]['start_memory_get_real_usage'] = memory_get_usage(true);
		$_ENV['analysis'][$key][$name]['start_memory_get_peak_usage'] = memory_get_peak_usage();
		$_ENV['analysis'][$key][$name]['start_memory_get_peak_real_usage'] = memory_get_peak_usage(true);
	}

	/**
	 * 结束性能分析
	 * @param string $name 分析名称
	 * @return array 分析结果
	 */
	public static function analysisStop($name) {
		$key = 'other';
		// 如果名称以 # 开头，则表示是插件分析
		if($name[0] === '#') {
			list(, $key, $name) = explode('#', $name);
		}
		// 如果分析已开始，则计算耗时和内存使用情况
		if(isset($_ENV['analysis'][$key][$name]['start'])) {
			$diff = round((microtime(TRUE) - $_ENV['analysis'][$key][$name]['start']) * 1000, 5);
			$_ENV['analysis'][$key][$name]['time'] = $diff;
			$_ENV['analysis'][$key]['sum'] = $_ENV['analysis'][$key]['sum'] + $diff;
			unset($_ENV['analysis'][$key][$name]['start']);
			$_ENV['analysis'][$key][$name]['stop_memory_get_usage'] = memory_get_usage();
			$_ENV['analysis'][$key][$name]['stop_memory_get_real_usage'] = memory_get_usage(true);
			$_ENV['analysis'][$key][$name]['stop_memory_get_peak_usage'] = memory_get_peak_usage();
			$_ENV['analysis'][$key][$name]['stop_memory_get_peak_real_usage'] = memory_get_peak_usage(true);
		}
		return $_ENV['analysis'][$key][$name];
	}
}

// 定义 C 类为 core 类的别名
class C extends core {}

// 定义 DB 类为 discuz_database 类的别名
class DB extends discuz_database {}

?>