// set routes
return [
	// class method
	'/' => 'IndexController->home',
	// namespace
	'login' => 'Account\UserController->login',
	// callable
	'logout' => function() { /* do something */ },
	// more routes
];

eco::route('GET@api/user/:id', function($id) { /* GET method */ });
eco::route('DELETE@api/user/:id', function($id) { /* DELETE method */ });
eco::route('POST@api/user/:id?', function($id = null) { /* POST method */ });
// or handle multiple HTTP methods
eco::route('POST|PUT@api/user/:id?', function($id = null) { /* POST or PUT method */ });

function auth() { /* do something */ }
eco::route('account/secure',
	['AccountController->secure', 'auth', function() { /* invoked */ }]);

eco::route('account*', 'AccountController::getRoutes()');

class AccountController
{
    public static function getRoutes()
    {
        return [
            'account/login' => 'AccountController->login',
            // do not have to use class name if in same class:
            'account/logout' => 'logout'
        ];
    }
}

eco::route('account*', [
    'AccountController', // the class name must be first (index:0)
    'account/login' => 'login',
    'account/logout' => 'logout'
]);

eco:route('bin/test/:id', function($id) {
    echo 'CLI test, id: ' . $id;
});

// this route will only work as CLI command
// the request '/bin/test/5' in a Web browser would result in a 404 error
eco:route('$bin/test/:id', function($id) {
    echo 'CLI test, id: ' . $id;
});

eco::route('user/:id', 'UserController->view');

class UserController
{
    public function view($id)
    {
        // do something
    }
}

eco::route('page/:id/:title?', function($id, $title = null) {});

eco::route('product/:info+', function($info) {
    // if request is '/product/1/abc/x'
    // $info is an array: ['1', 'abc', 'x']
});

eco::route('page/:title:strtoupper', 'PageController->view');

eco::route('page/:title', ['PageController->view', ['title' => 'strtoupper']]);

// globally set route param callback
// now every ':id' param will use this callback
// global param callbacks are overwritten by local ones
eco::param('id', function($id) { return strtoupper($id); });
// or use multiple param names:
eco::param(['x', 'y', 'z'], function($val) { });

eco::route('page/:title', [
  'PageController->view',
  'route_callback',
  function() { /* route callback */ },
  // route param callback
  ['title' => 'strtoupper']
]);

eco::route('user/:id@[0-9]+', ...);

// when using callback with regular expression
// the callback must come first:
eco::route('user/:id:strtoupper@[0-9]+', ...);

// use optional param and callback:
eco::route('user/:id/:name?:strtoupper', ...);

// use optional param and regular expression:
eco::route('user/:id/:name?@[a-z]+', ...);

// use optional param, callback and regular expression:
eco::route('user/:id/:name?:strtoupper@[a-z]+', ...);

// use wildcard param and callback:
eco::route('user/:params+:strtoupper', ...);

// use wildcard param and regular expression:
eco::route('user/:params+@[a-z]+', ...);

// use wildcard param, callback and regular expression:
eco::route('user/:params+:strtoupper@[a-z]+', ...);

class PageController
{
    public function get($id)
    {
        $page = PageModel::get($id);

        // set view param
        eco::view()->set('title', $page->title);

        // or use view() helper function
        // view()->set('title', $page->title);

        // or like this:
        view()->author = $page->author;

        // load template file 'page/view'
        // and can also set view param 'content'
        view('page/view', [
            'content' => $page->content
        ]);
    }
}

<?php include PATH_TEMPLATE_GLOBAL . 'header.tpl'; ?>
<h1><?=$title?></h1>
<p>Author: <?=$author?></p>
<?=$content?>
<?php include PATH_TEMPLATE_GLOBAL . 'footer.tpl'; ?>

eco::log()->error('Bad error / fatal');
eco::log()->warning('Warning conditions');
eco::log()->notice('Notice message');
eco::log()->debug('File has loaded');

// category 'payment'
eco::log()->error('Failed to access payment gateway', 'payment');

eco::log()->warning('Request failed', /* category optional */ null,
    ['request' => 'x', 'client' => 'y']);

$log = eco::log()->get();

eco::log()->setHandler(function($message, $level, $category, $info){
	// if sending message to database
    // do no send if database connection error, example:
    // if(substr($message, 0, 17) == 'SQLSTATE[HY000] [')
    // {
    // 	return false;
    // }

    // handle custom logging
    return true; // handled
});

eco::error('Error message');
// or use helper function
error('Something bad');
// custom error code
error('Page not found', 404);
// add log category
error('Failed to load user', null, 'account');
// by default the HTTP error response code is sent
// to not send HTTP code use:
error('Page not found', 404, 'category' false);

$error_message = eco::errorGetLast();
$error_category = eco::errorGetLastCategory();

// called before routing starts
eco::hook(eco::HOOK_BEFORE, function() { /* do something */ });

// called before the route callable or class method is called
// include a file example:
eco::hook(eco::HOOK_MIDDLE, PATH_LIB . 'hook/middle.php');

// called after dispatching
eco::hook(eco::HOOK_AFTER, function() { /* do something */ });

// load config file(s) using path
eco::conf(PATH_CONF . 'app.conf.php');
eco::conf(PATH_CONF . 'api.conf.php');

// or load config settings using array
eco::conf(['local' => ['path' => 'x', 'filename' => 'y']]);

// use config settings
$app_username = eco::conf()->app->username;
$local_path = eco::conf()->local->path;

return [
    'app' => [
        'username' => 'x',
        'password' => 'y'
    ],
    'core' => [ /* more */ ]
];

// do not store internally
$conf = eco::conf(PATH_CONF . 'app.conf.php', false);
// use config settings
$app_username = $conf->app->username;

// set Eco access class
class eco extends \Eco\System {}