<?php

/**
 * $Id: IoCFactory.php 64919 2015-06-08 05:48:03Z caoyangmin $
 * TODO: Reflection有性能问题
 * @author caoyangmin
 * @brief
 * IoCFactory
 */
namespace phprs\util;

/**
 * 依赖注入工厂
 * 创建实例, 并根据配置注入依赖
 * @author caoym
 *        
 */
class IoCFactory
{
    /**
     * @param string|array $conf 文件或者配置数组
     * 配置数组格式如下:
     * [
     *  id=>[
     *  "class"=>类名,
     *  "singleton"=>false, 是否是单例, 如果是, 则只会创建一份(同一个工厂内)
     *  "pass_by_construct"=false, 属性是否通过构造函数传递, 如果不是, 则通过访问属性的方式传递
     *  "properties"=>{
     *      属性名=>属性值
     *  }
     * @param array $dict 设置字典
     * 配置文件中, 属性值可以使用{key}的方式指定模板变量, 注入属性到实例是这些模板变
     * 量会被替换成setDict方法设置的值
     * @param array $metas 类元信息, 如果不指定, 则自动从类文件中导出
     * ]
     */
    public function __construct($conf=null, $dict=null, $metas=null)
    {
        if($conf === null){
            $this->conf = array();
        }elseif(is_array($conf)){
            $this->conf = $conf;
        }else{
            Verify::isTrue(is_file($conf), "$conf is not a valid file");
            if(strtolower(pathinfo($conf, PATHINFO_EXTENSION)) == 'php'){
                $this->conf = include($conf);
            }else{
                Verify::isTrue(false !== ($data = file_get_contents($conf)), "$conf open failed");
                $data = self::clearAnnotation($data);
                Verify::isTrue(is_array($this->conf = json_decode($data,true)), "$conf json_decode failed with ".json_last_error());
            }
            $this->conf_file = $conf;
        }
        if($dict !== null){
            $this->conf = $this->replaceByDict($this->conf, $dict);
        }
        $this->metas = $metas;
    }
    /**
     * 去掉注解
     * @param unknown $text
     */
    static public function clearAnnotation($text){
        return AnnotationCleaner::clean($text);
    }
    /**
     * 获取配置的属性
     * @param string $id
     * @return array|null
     */
    public function getConf($id=null){
        if($id === null){
            return $this->conf;
        }else{
            if(isset($this->conf[$id]) && isset($this->conf[$id]['properties'])){
                return $this->conf[$id]['properties'];
            }
            return null;
        }
    }
    /**
     * 
     * @param string $id
     */
    public function getClassName($id=null){
        if(isset($this->conf[$id])){
            $class = $this->conf[$id];
            if(isset($class['class'])){
                return $class['class'];
            }else{
                return $id;
            }
        }else{
            return $id;
        }
    }
    /**
     * 根据id得到对象实例
     * //TODO 单实例间互相引用会是问题
     * @param string $id
     * @param array $properties 类属性, 覆盖配置文件中的属性  
     * @param callable $injector fun($src), 获取注入值的方法
     * @param callable $init fun($inst, &$got) 初始化实例, 在创建后, 调用构造函数前
     * @param array $construct_args 构造函数的参数
     * @return object
     */
    public function create($id, $construct_args=null, $properties=null, $injector=null, $init=null )
    {
        if($properties === null){
            $properties = array();
        }
        if($construct_args===null){
            $construct_args = array();
        }
        $ins = null;
        $is_singleton = false;
        $class_name = $this->getClassName($id);
        if(isset($this->conf[$id])){
            $class = $this->conf[$id];
            $class_refl = new \ReflectionClass($class_name);
            // 如果是单例
            // 带构造参数的类不支持单例
            if (count($properties) ===0 && count($construct_args) === 0 && isset($class['singleton']) && $class['singleton']) {
                $is_singleton = true;
                if (isset($this->singletons[$id])) {
                    $ins = $this->singletons[$id];
                    Logger::info("get {$id}[$class_name] as singleton");
                    return $ins;
                }
            }
            if(isset($class['properties'])){
                $properties = array_merge($class['properties'], $properties);
            }

            if (isset($class['pass_by_construct']) && $class['pass_by_construct']){ //属性在构造时传入
                Verify::isTrue(count($construct_args) ===0, "$class_name pass_by_construct"); //构造时传输属性, 所以不能再传入其他构造参数
                //组合构造参数
                $construct_args = $this->buildConstructArgs($class_refl, $properties);
                $properties=array();
            }
        }else{
            $class_refl = new \ReflectionClass($class_name);
        }
        if(!$is_singleton){
            if (array_search($id, $this->create_stack) !== false){
                $tmp = $this->create_stack;
                Verify::e("create $id failed, cyclic dependencies can only used with singleton. cyclic:".print_r($tmp,true));
            }
            $this->create_stack[] = $id;
        }
        
        try {
            if (isset($class['pass_by_construct']) && $class['pass_by_construct']){
                $ins = $class_refl->newInstanceArgs($construct_args);
                $meta = $this->getMetaInfo($class_refl);
                if ($is_singleton){
                    $this->singletons[$id] = $ins;
                }
                $this->injectDependent($class_refl, $ins, $meta, $properties, $injector);
            }else{
                $nti = new NewThenInit($class_refl);
                $ins = $nti->getObject();
                $meta = $this->getMetaInfo($class_refl);
                if ($is_singleton){
                    $this->singletons[$id] = $ins;
                }
                $this->injectDependent($class_refl, $ins, $meta, $properties, $injector);
                if($init !==null){
                    $init($ins);
                }
                $nti->initArgs($construct_args);
            }
        } catch (\Exception $e) {
            array_pop($this->create_stack);
            throw $e;
        }
        array_pop($this->create_stack);
        
        Logger::info("create {$id}[$class_name] ok");
        return $ins;
    }
    /**
     * 取配置文件路径, 如果是通过数组创建的, 则返回null
     * @return string|NULL
     */
    public function getConfFile(){
        return $this->conf_file;
    }
    /**
     * 配置中是否有指定id的类
     * @param string $id
     * @return boolean
     */
    public function hasClass($id){
        return isset($this->conf[$id]);
    }
    /**
     * 设置属性值, 允许设置private/protected属性
     * @param $refl
     * @param object $class
     *            类名或实例
     * @param string $name
     *            属性名
     * @param mixed $value
     *            属性值
     */
    static function setPropertyValue($refl, $ins, $name, $value)
    {
        Verify::isTrue($m = $refl->getProperty($name));
        $m->setAccessible(true);
        $m->setValue($ins, $value);
    }
    /**
     * 取属性值
     * @param $refl
     * @param object $ins
     * @param string $name
     * @return mixed
     */
    static function getPropertyValue($refl, $ins, $name)
    {
        Verify::isTrue($m = $refl->getProperty($name));
        $m->setAccessible(true);
        return $m->getValue($ins);
    }
    /**
     * 获取元信息
     * 会缓存
     * @param string $class
     * @return array
     */
    public function getMetaInfo($class){
        if(is_string($class)){
            $refl = new \ReflectionClass($class);
        }else{
            $refl = $class;
        }
        $name = $refl->getName();
        if($this->metas !==null && isset($this->metas[$name])){
            return $this->metas[$name];
        }
        static $cache = null;
        if($cache === null){
            $cache = new Cache();
        }
        $succeeded = false;
        $cache_key = 'meta_'.sha1($refl->getFileName().'/'.$name);
        $data = $cache->get($cache_key, $succeeded);
        if($succeeded){
            return $data;
        }
        MetaInfo::testAnnotation();
        $data = MetaInfo::get($name);
        $files = [$refl->getFileName()];
        $parent = $refl->getParentClass();
        if($parent){
            $files[] = $parent->getFileName();
        }
        foreach ($refl->getInterfaces() as $i){
            $files[] = $i->getFileName();
        }
        $cache->set($cache_key, $data, 60, new FileExpiredChecker($files));
        return $data;
    }
    
    /**
     * 根据属性组合构造参数
     * @param ReflectionClass $class
     * @param array $properties
     * @return array
     */
    private function buildConstructArgs($class, $properties){   
        if($properties===null) {
            return array();
        }
        if(count($properties)==0){
            return array();
        }
        $refMethod = $class->getConstructor();
        $params = $refMethod->getParameters();
        $args = array();
        foreach ($params as $key => $param) {
            $param_name = $param->getName();
            if(isset($properties[$param_name])){
                $args[$key] = $this->getProperty($properties[$param_name]);
            }else{
                Verify::isTrue($param->isOptional(), "{$class->getName()}::__construct miss required param: $param_name");//参数没有指定, 除非是可选参数
                break;
            }
        }
        return $args;  
    }
    /**
     * 获取属性
     * 替换属性中的{}和@标记
     * @param string $value
     * @return object|string
     */
    private function getProperty($value){
        if (is_string($value) && substr($value, 0, 1) == '@') {
            return $this->create(substr($value, 1));
        } else {
            return $value;
        }
    }

    /**
     * 注入依赖
     * @param ReflectionClass $refl;
     * @param unknown $ins        
     * @param unknown $meta         
     * @param unknown $properties     
     * @return void       
     */
    public function injectDependent($refl, $ins, $meta, $properties, $injector=null)
    {
        $defaults=array();
        $class_name = $refl->getName();
        $class_defaults = $refl->getDefaultProperties();
        if(isset($meta['property']) ){
            foreach ($meta['property'] as $property => $value) {
                //参数是否可选
                if(isset($value['value']) && isset($value['value']['optional']) && $value['value']['optional']){
                    continue;
                }
                //设置了默认值
                if(isset($value['value']) && isset($value['value']['default'])){
                    $defaults[$property] = $value['value']['default'];
                    continue;
                }
                // 是否设置了默认值
                if (array_key_exists($property, $class_defaults)) {
                    continue;
                }
                Verify::isTrue(array_key_exists($property, $properties), "$class_name::$property is required");
            }
        }
        // 设置属性
        if ($properties !== null) {
            foreach ($properties as $name => $value) {
                unset($defaults[$name]);
                $v = $this->getProperty($value);
                self::setPropertyValue($refl, $ins, $name, $v);
            }
        }
        // 注入依赖
        if(isset($meta['inject'])){
            foreach ($meta['inject'] as $property => $value) {
                //先设置必须的属性
                if(is_array($value['value'])){
                    $src = $value['value']['src'];
                    //参数是否可选
                    if(isset($value['value']) && isset($value['value']['optional']) && $value['value']['optional']){
                        continue;
                    }
                    //设置了默认值
                    if(isset($value['value']) && isset($value['value']['default'])){
                        $defaults[$property] = $value['value']['default'];
                        continue;
                    }
                }else{
                    $src = $value['value'];
                }
                //是否设置了默认值
                if(array_key_exists($property, $class_defaults)){
                    continue;
                }
                if ($src === "ioc_factory" || $src == "factory"){
                    continue;
                }else{
                    $got = false;
                    Verify::isTrue($injector !==null , "$class_name::$property is required");
                    $val = $injector($src, $got);
                    Verify::isTrue($got , "$class_name::$property is required");
                    self::setPropertyValue($refl, $ins, $property, $val);
                    unset($meta['inject'][$property]);
                }
            }
            //在设置可选的
            foreach ($meta['inject'] as $property => $value) {
                if(is_array($value['value'])){
                    $src = $value['value']['src'];
                }else{
                    $src = $value['value'];
                }
                if ( $src == "ioc_factory" || $src == "factory") {
                    self::setPropertyValue($refl, $ins, $property, $this);
                    unset($defaults[$property]);
                }else if($injector){
                    $val = $injector($src, $got);
                    if($got){
                        self::setPropertyValue($refl, $ins, $property, $val);
                        unset($defaults[$property]);
                    }
                }  
            }
        }
        // 设置默认属性
        foreach ($defaults as $name => $value ){
            unset($defaults[$name]);
            $v = $this->getProperty($value);
            self::setPropertyValue($refl, $ins, $name, $v);
        }
    }

    /**
     * 替换字典
     * @see setDict
     * @param string|array $value
     * @return void
     */
    private function  replaceByDict($value, $dict){       
        if(is_string($value)){
            $keys = $this->getDictKeys($value);
            foreach ($keys as $key){
                Verify::isTrue(isset($dict[$key]), "{$key} not specified");
            }
            foreach ($dict as $key=>$replace){
                $value = str_replace('{'.$key.'}', $replace, $value);
            }
            return $value;
        }else if(is_array($value)){
            foreach ($value as $k=>$v){
                $value[$k] = $this->replaceByDict($v, $dict);
            }
            return $value;
        }else{
            return $value;
        }
    }
    /**
     * 从字符串中获取模板变量
     * @param string $value
     * @return array
     */
    static function  getDictKeys($value){
        preg_match_all('/\{([0-9a-zA-Z\-\_]*?)\}/', $value, $params);
        $params += array(null, array());
        return $params[1];
    }
    protected $metas; 
    protected $singletons = array();
    protected $conf = null;
    protected $dict = array();
    protected $conf_file;
    private $create_stack=array(); // 正在创建的类，用于检测循环依赖
}