1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 

<?php

    namespace Deliverist\Builder;

    use CzProject\PathHelper;
    use CzProject\Runner;
    use Nette\Utils\Callback;
    use Nette\Utils\FileSystem;


    class Builder
    {
        const DEBUG = 0;
        const INFO = 1;
        const SUCCESS = 2;
        const WARNING = 3;
        const ERROR = 4;

        const MAKE_START = 0;
        const MAKE_END = 1;

        /** @var callback[]  (message, type) */
        public $onLog;

        /** @var callback[]  (command name, type self::MAKE_*) */
        public $onMake;

        /** @var string */
        private $directory;

        /** @var array  [name => command] */
        private $commands;

        /** @var Runner\Runner */
        protected $runner;


        /**
         * @param  string
         * @param  ICommand[]
         */
        public function __construct($directory, array $commands = array())
        {
            $this->directory = PathHelper::absolutizePath($directory);
            $this->commands = $commands;
            $this->runner = $this->createRunner($this->directory);
        }


        /**
         * @param  string|NULL
         * @return string
         */
        public function getPath($path = NULL)
        {
            return PathHelper::absolutizePath($this->directory . '/' . $path);
        }


        /**
         * @param  string|ICommand|callback
         * @return self
         * @throws BuilderException
         */
        public function make($command/*, ...*/)
        {
            $cmd = $command;
            $commandName = 'callback';

            if (is_string($command)) {
                if (!isset($this->commands[$command])) {
                    throw new BuilderException("Missing command '$command'.");
                }

                $commandName = $command;
                $cmd = $this->commands[$command];
            }

            $args = func_get_args();
            array_shift($args);
            array_unshift($args, $this);

            $this->fireEvent($this->onMake, array($commandName, self::MAKE_START));

            if ($cmd instanceof ICommand) {
                Callback::invokeArgs(array($cmd, 'run'), $args);

            } else {
                Callback::invokeArgs($cmd, $args);
            }

            $this->fireEvent($this->onMake, array($commandName, self::MAKE_END));

            return $this;
        }


        /**
         * @param  string|array
         * @param  string|NULL
         * @return Runner\RunnerResult
         */
        public function execute($cmd, $subdir = NULL)
        {
            return $this->runner->run($cmd, $subdir);
        }


        /**
         * @param  string
         * @return string
         */
        public function readFile($file)
        {
            return FileSystem::read($this->getPath($file));
        }


        /**
         * @param  string
         * @param  string
         * @return void
         */
        public function writeFile($file, $content)
        {
            FileSystem::write($this->getPath($file), $content);
        }


        /**
         * @param  string
         * @return void
         */
        public function delete($path)
        {
            FileSystem::delete($this->getPath($path));
        }


        /**
         * @param  string
         * @param  int
         * @return self
         */
        public function log($message, $type = self::INFO)
        {
            $this->fireEvent($this->onLog, array($message, $type));
            return $this;
        }


        /**
         * @param  string
         * @return self
         */
        public function logDebug($message)
        {
            return $this->log($message, self::DEBUG);
        }


        /**
         * @param  string
         * @return self
         */
        public function logWarning($message)
        {
            return $this->log($message, self::WARNING);
        }


        /**
         * @param  string
         * @return self
         */
        public function logError($message)
        {
            return $this->log($message, self::ERROR);
        }


        /**
         * @param  string
         * @return self
         */
        public function logSuccess($message)
        {
            return $this->log($message, self::SUCCESS);
        }


        /**
         * @param  string
         * @return Runner\Runner
         */
        protected function createRunner($directory)
        {
            return new Runner\Runner($directory);
        }


        /**
         * @param  array|NULL
         * @param  array
         * @return void
         */
        private function fireEvent($handlers, array $args = array())
        {
            if (!is_array($handlers)) {
                return;
            }

            foreach ($handlers as $handler) {
                Callback::invokeArgs($handler, $args);
            }
        }
    }