<?php
/**
 *      Name:  framework/libs.php
 *      Purpose:      Include core libraries, define default page and action
 */
error_reporting(E_STRICT | E_ALL);

define('PATH_FRAMEWORK',        realpath(dirname(__FILE__)));
define('PATH_CONTROLLER',       PATH_FRAMEWORK.'/Controller');
define('PATH_FILTER',      PATH_FRAMEWORK.'/Filter');
define('PATH_MODEL',        PATH_FRAMEWORK.'/Model');
define('PATH_VIEW',          PATH_FRAMEWORK.'/View');


function __autoload($class)
{
        include_once(PATH_FRAMEWORK.'/'.$class.'.php');
}

/**
 *      Name:  framework/FilterManager.php
 *      Purpose:      Manage pre and post-execution Filters for a Controller
 */
class FilterManager
{
        public $controller = NULL;
        public $prefilters = array();
        public $postfilters = array();
       
        /**
         * @param object Controller
         */
        public function __construct(Controller $c)
        {
                $this->controller = $c;
        }
       
        /**
         * Add a filter to be executed before Controller execution
         */
        public function addPreFilter($f)
        {
                $this->prefilters[] = Filter::create($f);
        }
        /**
         * Add a filter to be executed after Controller execution
         */
        public function addPostFilter($f)
        {
                $this->postfilters[] = Filter::create($f);
        }
       
        /**
         * Execute 1) prefilters 2) Controller 3) postfilters
         * @param mixed passed to Controller, optional
         */
        public function execute($param = NULL)
        {
                foreach($this->prefilters as $f)
                        $f->execute($this);
               
                $this->controller->execute($param);
               
                foreach($this->postfilters as $f)
                        $f->execute($this);
        }
}


/**
 *      Name:  framework/Filter.php
 *      Purpose:      Provide site-wide auxiliary function plugins
 */
abstract class Filter
{
        abstract function execute(FilterManager $fm);
       
        public function create($type)
        {
                $path = PATH_FILTER.'/'.$type.'.php';
                $class = $type.'Filter';
                return Factory::Generic($path, $class);
        }
}

/**
 *      Name:  framework/Controller.php
 *      Purpose:      Provide basic Controller implementation
 */
abstract class Controller
{
        abstract public function execute($parameter);
       
        /**
         * Create a Controller of certain type
         * @param string Controller type
         * @param object parent Controller, optional
         */
        static function create($type, $parent = NULL)
        {
                $type = ucfirst($type);
                $path = PATH_CONTROLLER.'/'.$type.'.php';
                $class = $type.'Controller';
                $args = array();
                if($parent instanceof Controller)
                        $args[] = $parent;
               
                return Factory::Generic($path, $class, $args);
        }
}

/**
 *      Name:  framework/FrontController.php
 *      Purpose:      Dispatch page request to a PageController
 */
class FrontController extends Controller
{
        protected $default_page = NULL;
        protected $default_action = NULL;

        /**
         * FrontController constructor
         * @param string default page
         * @param string default action
         */
        public function __construct($default_page, $default_action)
        {
                $this->default_page = $default_page;
                $this->default_action = $default_action;
        }
       
        /**
         * Create Controller based on $request, execute it, render the created view
         * @param array request resource (typically $_GET)
         */
        public function execute($request)
        {
                $page = (isset($request['page']) && is_string($request['page'])) ? $request['page'] :  $this->default_page;
                $action = (isset($request['action']) && is_string($request['action'])) ? $request['action'] :  $this->default_action;
               
                $p = Controller::create($page);
                $p->execute($action);
               
                $view = $p->getView();
                $view->render();
        }
}

/**
 *      Name:  framework/PageController.php
 *      Purpose:      Govern application logic.
 *      Allow extending Controllers to host page actions, interact with the View and execute sub-actions
 */
abstract class PageController extends Controller
{
        protected $parent = NULL;
        protected $children = array();
        protected $view = NULL;
        protected $model = NULL;
        protected $name = NULL;
       
        /**
         * PageController constructor
         * @param object parent-PageController
         */
        public function __construct($parent = NULL)
        {
                $this->name = get_class($this);
                if($parent instanceof Controller)
                {
                        $this->parent = $parent;
                        $this->view = $parent->view;
                }
                else
                {
                        $this->view = new View();
                }
                $this->initialize();
        }
       
        /**
         * Initialization: associate PageController with appropriate Model
         */
        abstract protected function initialize();
       
        /**
         * Execute PageController action
         * @param string action name
         */
        public function execute($action)
        {
                        $this->checkAction($action);
                       
                        $this->onExecute();
                        $this->$action();
                        $this->afterExecute();
        }
       
        /**
         * Return View-object associated with PageController
         */
        public function getView()
        {
                return $this->view;
        }
       
        /**
         * Check that an action is allowed, throw Exception on error
         * @param string action name
         */
        protected function checkAction($action)
        {
                if(method_exists($this, $action))
                {
                        $method = new ReflectionMethod(get_class($this), $action);
                        $reserved = array('__construct', 'execute', 'getView');
                        if(in_array($action, $reserved) || $method->isProtected() || $method->isPrivate() || $method->isStatic())
                                throw new Exception('Tried to execute reserved action '.$action.' in '.$this->name);
                }
                else
                        throw new Exception($this->name.' does not support action '.$action);
        }
       
        /**
         * Execute action in a child-controller
         * @param string Controller type
         * @param string method name
         */
        protected function subAction($page, $action)
        {
                if(!isset($this->children[$page]))
                        $this->children[$page] = Controller::create($page, $this);
                $this->children[$page]->execute($action);
        }
       
        /**
         * Event handler: ran before executing an action
         */
        protected function onExecute() {}
        /**
         * Event handler: ran after executing an action
         */
        protected function afterExecute() {}
}


/**
 *      Name:  framework/View.php
 *      Purpose:      Handle templates
 */
class View
{
        public $templates = array();
        public $vars = array();
       
        /**
         * Assign template variable
         * @param string variable name
         * @param mixed variable value
         */
        public function assign($name, $value)
        {
                $this->vars[$name] = $value;
        }
       
        /**
         * Add template to stack
         * @param string filename
         */
        public function add($filename)
        {
                $path = PATH_VIEW.'/'.$filename;
                if(file_exists($path))
                        $this->templates[] = $path;
                else
                        throw new Exception('Template file '.$filename.' could not be found.');
        }
       
        /**
         * Clear template stack
         */
        public function clear()
        {
                $this->templates[] = array();
        }
       
        /**
         * Render template stack
         */
        public function render()
        {
                extract($this->vars);
                foreach($this->templates as $filename)
                        include $filename;
                $this->clear();
        }
}


/**
 *      Name:  framework/Model.php
 *      Purpose:      Provide basic Model implementation.
 *     
 *      In reality, this could be eg. database abstraction. Now it's just a shell.
 */
abstract class Model
{
        /**
         * Create a Model of certain type
         * @param string Model type
         */
        public function create($type)
        {
                $path = PATH_MODEL.'/'.$type.'.php';
                $class = $type.'Model';
                return Factory::Generic($path, $class);
        }
}


/**
 *      Name:  framework/Factory.php
 *      Purpose:      Host generic object factoring methods
 */
class Factory
{
        /**
         * Generic object factory method
         * @param string class definition path
         * @param string class name
         * @param array class constructor arguments
         */
        static public function Generic($path, $class, $args = array())
        {
                if(file_exists($path))
                {
                        include_once($path);
                        if(class_exists($class))
                        {
                                $arglist = array();
                                foreach($args as $index => $value)
                                        $arglist[] = '$args['.$index.']';
                                $arglist = implode(',',$arglist);
                               
                                $new_class = create_function('$class, $args', 'return new $class('.$arglist.');');
                                return $new_class($class, $args);
                        }
                        else
                                throw new Exception($path.' did not contain definition for '.$class);
                }
                else
                {
                        throw new Exception('Class definition file '.$path.' could not be found.');
                }
        }
}





/******************************************************************************
 *      Example with a pre-filter, a single page and action
 *****************************************************************************/





/**
 *      Name:  index.php
 *      Purpose:      Function as a single access point to the site
 */
include('framework/libs.php');

$default_page = 'Message';
$default_action = 'index';

try
{
        $fc = new FrontController($default_page, $default_action);
        $fm = new FilterManager($fc);
        $fm->addPreFilter('CleanRequest');
        $fm->execute($_GET);
}
catch(Exception $e)
{
        echo 'Exception: '.$e->getMessage();
}

/**
 *      Name:  framework/Filter/CleanRequest.php
 *      Purpose:      Clean request data ($_GET, $_POST, $_COOKIE and $_REQUEST) from magic quotes.
 */
class CleanRequestFilter
{
        public $isMagic = NULL;
        public function execute(FilterManager $fm)
        {
                if($this->isMagic = get_magic_quotes_gpc()) {
                        $_POST    = $this->fixMagicQuotes($_POST);
                        $_GET     = $this->fixMagicQuotes($_GET);
                        $_COOKIE  = $this->fixMagicQuotes($_COOKIE);
                        $_REQUEST = $this->fixMagicQuotes($_REQUEST);
                }
        }

  /**
   * Cleans arrays ruined by MagicQuotes=On.
   */
        protected function fixMagicQuotes($aList, $aIsTopLevel = true)
        {
                $gpcList = array();
                $isMagic = $this->isMagic;
                foreach ($aList as $key => $value)
                {
                        if(is_array($value))
                        {
                                $decodedKey = ($isMagic && !$aIsTopLevel)?stripslashes($key):$key;
                                $decodedValue = self::fixMagicQuotes($value, false);
                        }
                        else
                        {
                                $decodedKey = stripslashes($key);
                                $decodedValue = ($isMagic)?stripslashes($value):$value;
                        }
                        $gpcList[$decodedKey] = $decodedValue;
                }
                return $gpcList;
        }
}

/**
 *      Name:   framework/Model/Message.php
 */
class MessageModel extends Model
{
        protected $message = 'Hello, world!';
        public function getMessage()
        {
                return $this->message;
        }
}

/**
 *      Name:   framework/Controller/Message.php
 *      Purpose:      PageController for Message
 */
class MessageController extends PageController
{
        protected function initialize()
        {
                $this->model = Model::create('Message');
        }
       
        public function index()
        {
                $message = $this->model->getMessage();
                $this->view->assign('message', $message);
                $this->view->add('message_index.htm');
        }
}

/**
 *      Name:  framework/View/message_index.htm
 */
?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
        <title> Model-View-Controller example </title>
  <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
</head>
<body>
        <h1><?php echo $message ?></h1>
</body>
</html>