<?php
//$Id

function &_dependency($mods = false) {
  static $modules;
  if( $mods ) {
    $modules = $mods;
  }
  return $modules;  
}

function dependency_get_all() {
  return _dependency();
}

function dependency_set_all( &$modules ) {
  _dependency($modules);
}

function dependency_set_module( $name, $data ) {
  $modules =& _dependency();
  $modules[$name] = $data;
}

function dependency_get_module( $name ) {
  $modules =& _dependency();
  return $modules[$name];
}

function dependency_get_module_names() {
  return array_keys(_dependency());
}

function dependency_module_property($module, $property) {
  $modules =& _dependency();
  return $modules[$module][$property];
}

function dependency_set_module_property($module, $property, $data) {
  $modules =& _dependency();
  return $modules[$module][$property]=$data;
}

function dependency_module_available($module) {
  $modules =& _dependency();
  
  return array_key_exists($module,$modules);
}

/**
* a dummy callback, to be used in dependency resolution
*/
function dependency_callback($stage,$module) {
  return true;
}

function dependency_validate_callback($stage,$module) {
  return dependency_module_available($module);
}

function dependency_error_callback($stage,$module) {
  $broken =& dependency_broken();
  $broken[$module]=$module;
  return false;
}

function & dependency_broken() {
  static $broken=false;
  
  if(!$broken){
    $callback='dependency_callback';
    $validate_callback='dependency_validate_callback';
    $error_callback='dependency_error_callback';

    $modules=dependency_get_module_names();
    dependency_process(array('check dependency'),$modules, $callback,$validate_callback,$error_callback);
  }
  return $broken;
}

function dependency_is_broken($module) {
  $broken=dependency_broken();
  
  return isset($broken[$module]);
}

function dependency_missing($module) {
  $broken=dependency_broken();
  
  return $broken[$module];
}

/** log the processing of $stage,$module
* @param $stage - string, a processing stage
* @param $module - string, the module name
*/
function  dependency_log($stage,$module) {
  return _dependency_log($stage, $module);
}

/** check if the $module has been processed for $stage
* @param $stage - string, a processing stage
* @param $module - string, the module name
* @return boolean
*/
function dependency_is_processed($stage,$module) {
  return _dependency_log($stage, $module, FALSE, FALSE);
}


/**
* execute/process the dependencies
* @param $stages the installation/process stages
* @param $modules the modules to install
* @param callback the callback to call, takes $stage,$module as parameters
* @return $trace - the callstack ( will be deprecated in production )
*/
function dependency_process($stages, $modules, $callback,$validate_callback,$error_callback) {
  //for the moment handle only 'depends' - a must, not optional dependency
  $type='depends';
  $result = FALSE;
  
  foreach($stages as $stage) {
    foreach($modules as $module) {
      $result[$module] = _dependency_process( $stage, $module, $callback,$validate_callback,$error_callback);
    }
  }
  return $result;
}

/** for internal use, recursively walks the module dependencies
*  for the named stage and executes the callback function
*  this function is to be called exclusively from dependency_process()
* @param $stages the installation/process stages
* @param $modules the modules to install
* @param $callback the callback to call, takes $stage,$module as parameters
* @param $validate_callback - a condition to ensure that a callback is safe to be called
* @param $error_callback - called if $validate_callback fails
* all callbacks have the callback($stage,$module) signature, additionally
* $validate_callback should return false in case of failure
* @return $trace - the callstack ( will be deprecated in production )
* @TODO drupalify this, instead of a callback use a hook, will allow for
* flexible stages
*/
function _dependency_process( $stage, $module, $callback,$validate_callback,$error_callback) {

  $log = dependency_is_processed($stage,$module);

  $result=array();
  $guard=true;
  if(!$log) {
    //flag it up as installed, prevents endless recursion,
    //possible due to cyclic dependencies
    dependency_log($stage,$module);
    //is it feasible to have other property types here like
    //provides: or recommends: ???
    $guard=true;

    $deps=dependency_module_property($module,'depends');
    if($deps) {
      foreach($deps as $mod) {
        //guarantee that the modules $module depends on are processed first
        //we can provide a bail-out callback here. if the callback decides
        //that something is wrong - missing dependency, for example,
        //what do we do?
        $validate[$mod] = $validate_callback($stage,$mod);
        $guard = $guard && $validate[$mod];
  
        if($validate[$mod]) {
          $result[$mod]=_dependency_process($stage, $mod, $callback, $validate_callback, $error_callback);
        } else {
          $result[$mod]=$error_callback($stage,$mod);
        }
      }
    }
    //check for propagated errors from the children
    $guard = $guard && !in_array(false,$result);
    if($guard) {
      $callback($stage,$module);
    }
  }
  return $guard;
}

/** log processing, for internal use only
*
*/
function & _dependency_log($stage=FALSE,$module=FALSE, $full=FALSE, $set = TRUE) {
  static $log=array();

  if($stage && $module && $set) {
    $log[$stage][$module]=TRUE;
  }
  
  if($stage && $module && !$full) {
    return $log[$stage][$module];
  }
  
  return $log;
}

/** parses in a .dsc file
* @param $file the path to the file (filesystem, http, ftp,...)
* @return array of the description structure
*/
function dependency_parse_dsc( $lines) {
  foreach($lines as $line) {
    list($var,$value)=explode(':',$line);
    if($var=='module') {
      $module=trim($value);
    } elseif( isset($module)) {
      
      $dsc[$module][$var] = explode(',',trim($value));
    }
  }
  return $dsc;
}


function dependency_process_files($files,$repository,$out_callback=NULL,$error_callback=NULL) {
  //fopen works with remote files
  if(function_exists($out_callback)) {
    $out_callback("PROCESSING: \n");
  }
  
  foreach($files as $file) {
    $lines[]= 'module:'.$file->name."\n";
    $lines[]= 'repository:'.$repository."\n";
    $lines[]= 'path:'.$file->dir."\n";

    if(is_file($file->dir.'/'.$file->name.'.mysql')) {
      $lines[]='schema: 1';
    } //doesn't work for core, since the schema is in database.(my|pg)sql
    
    //fopen works with remote files
    if(function_exists($out_callback)) {
      $out_callback(' '.$file->name.' ');
    }

    if($hd=@fopen($file->filename,'r')) {
      //ugly, but works..., might be improved
      
      //UGLY - IMPROVE
      $content = fread($hd, filesize ($file->filename));
      $depends=null;
      foreach($files as $fd) {
        if($test=preg_match('/'.$fd->name.'_[a-z_]+/',$content)&& ($fd->name!=$file->name)) {
          //match the first part of the function with a filename
          //to improve the precision match the function name in the file
          //$functions = dependency_parse_php(file_get_contents($fd->filename));
          //if(in_array($test,$functions)) {
            $depends[]=$fd->name;
          //}
        }
      }
      if(is_array($depends)) {
        $lines[]='depends:'. implode(',',$depends)."\n";
      }
      fclose ($hd);
    }
  }
  return $lines;
}

function dependency_parse_php($buffer){
  $tokens = token_get_all($buffer);
  foreach ($tokens as $token) {
    if(is_array($token)&&$token[0]==T_FUNCTION) {
      $skip_white=true;
    }
    if($skip_white&&is_array($token)&&$token[0]==T_STRING) {
      $functions[]=$token[1];
      $skip_white=false;
    }    
  }
  return $functions;
}

function dependency_functions() {
  $modules=dependency_get_module_names();
  $data = dependency_get_all();
  $path = dependency_module_property();
  foreach($modules as $name) {
    $path = dependency_module_property($name,'path');
    $file = $path[0].'/'.$name.'.module';
    $functions = dependency_parse_php(file_get_contents($file));
    dependency_set_module_property($name, 'functions', $functions);
  }
}

?>