<php?
/*
 * ManifestBuilder code is distributed under LGPL 3
 * Copyright (C) 2014 Vladimir Guloyants vladimir@guloyants.net
 * 
 * This class is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or any later version.
 *
 * This class is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
*/

/**
 * ManifestBuilder dynamically   creates a manifest  file that contains a 
 * list of the resources for the browser’s Application Cache.
 *  
 * @author Vladimir Guloyants vladimir@guloyants.net
 * @version 0.2.13 
 * @access   public
 */
class ManifestBuilder {

    const SECTION_CACHE     = 'cache';
    const SECTION_NETWORK   = 'network';
    const SECTION_FALLBACK  = 'fallback';
    const DEBUGMODE_ON      = true;
    const DEBUGMODE_OFF     = false;
    const AS_STRING         = true;

    /**
     * Controls debugging behavior. 
     * Set on true adds random hash to Manifest footer.
     * 
     * @var boolean
     */
    protected $debugMode = false;

    /**
     * Array of files for CACHE section
     * 
     * @var array
     */
    protected $cacheResources = [];

    /**
     * Array of files for NETWORK section
     * 
     * @var array
     */
    protected $networkResources = [];

    /**
     * Array of files for FALLBACK section
     * 
     * @var array
     */
    protected $fallbackResources = [];

    /**
     * HashString for all cached files.
     * Used to trigger Manifest update on file change
     * 
     * @var string
     */
    protected $hashes = '';
    protected $version = 1;

    /**
     * @param mixed $version Your manifest version
     * @param boolean $debugMode switch on the debbug
     */
    public function __construct($version = 1, $debugMode = false) {
        $this->setVersion($version);
        $this->setDebugMode($debugMode);
    }
    
    /**
     * Adds resource or array of resources to manifest section
     * ('cache', 'network', 'fallback') 
     * 
     * @param array $resources (list of resources)
     * @param string $section  Section of manifest the resources will be added to
     * @return ManifestBuilder
     * @throws \Exception
     */
    public function addResources(array $resources, $section = self::SECTION_CACHE) {
        foreach ($resources as $resource) {
            if (self::SECTION_CACHE === $section) {
                $this->cacheResources[] = $resource;
            } elseif (self::SECTION_FALLBACK === $section) {
                $this->fallbackResources[] = $resource;
            } elseif (self::SECTION_NETWORK === $section) {
                $this->networkResources[] = $resource;
            } else {
                throw new \Exception('Section name ' . $section . ' don\'t exist.');
            }
        }
        $this->attachResourceToHash($resource);
        return $this;
    }

    /**
     * Adds resources recurcively from given directory and subdirectories.
     * 
     * @param string $dir
     * @param string $section
     * @return ManifestBuilder
     */
    public function addResourcesFromDirectory($dir, $section) {
        $resources = $this->recursiveFileWalk($dir);
        return $this->addResources($resources, $section);
    }

    /**
     * Prints out the manifest file after resources was set.
     * Throws exception, if no resources found.
     * 
     * @return boolean
     * @throws \Exception
     */
    public function flush() {
        if ($this->manifestIsEmpty()) {
            throw new \Exception('Manifest has no resources.');
        }
        $this->documentHeader();
        $this->manifestHeader();
        $this->manifestBody();
        $this->manifestFooter();
        return true;
    }

    /**
     * @param string $version
     * @return ManifestBuilder
     */
    public function setVersion($version) {
        $this->version = $version;
        return $this;
    }

    /**
     * Applies the debug mode
     * 
     * @param bool $debugMode
     * @return ManifestBuilder
     */
    public function setDebugMode($debugMode) {
        if (is_bool($debugMode)) {
            $this->debugMode = $debugMode;
        } else {
            $this->debugMode = (boolean) $debugMode;
        }
        return $this;
    }

    /**
     * Returns array of resources for given section
     * 
     * @param string $section
     * @return array
     * @throws \Exception
     */
    public function getResourcesBySection($section = self::SECTION_CACHE) {
        if (self::SECTION_CACHE === $section) {
            return $this->cacheResources;
        } elseif (self::SECTION_NETWORK === $section) {
            return $this->networkResources;
        } elseif (self::SECTION_FALLBACK === $section) {
            return $this->fallbackResources;
        } else {
            throw new \Exception('Section name ' . $section . 'don\'t exist.');
        }
    }
    
    /**
     * 
     * @return bool
     */
    public function getDebugMode() {
        return $this->debugMode;
    }
    
    /**
     * @return string
     */
    public function getVersion() {
        return $this->version;
    }
    
    /**
     * @param string $dir
     * @return \RecursiveIteratorIterator
     */
    protected function recursiveFileWalk($dir = '.') {
        $files = [];
        $dirs = new \RecursiveDirectoryIterator($dir);
        foreach (new \RecursiveIteratorIterator($dirs) as $file) {
            if ($this->fileIsValid($file, $dirs)) {
                $files[] = $file;
            }
        }
        return $files;
    }
    
    /**
     * Determines headers
     */
    protected function documentHeader() {
        header("Cache-Control: max-age=0, no-cache, no-store, must-revalidate");
		header("Pragma: no-cache");
        header('Content-Type: text/cache-manifest; charset=UTF-8');
    }
    
    /**
     * Renders manifest header
     */
    protected function manifestHeader() {
        echo "CACHE MANIFEST\n\n";
        echo '# Version: ' . $this->version . "\n\n";
    }
    
    /**
     * Renders manifest body
     */
    protected function manifestBody() {
        $sections = [self::SECTION_CACHE, self::SECTION_NETWORK, self::SECTION_FALLBACK];
        foreach ($sections as $section) {
            $resources = $this->getResourcesBySection($section);
            if (!empty($resources)) {
                echo $this->getSectionHeader($section);
                foreach ($resources as $resource) {
                    echo $resource . "\n";
                }
            }
        }
    }
    
    /**
     * Renders manifest footer
     */
    protected function manifestFooter() {
        echo '# Hashes: ' . $this->hashes . "\n\n";
        if ($this->getDebugMode()) {
            echo '# Debug timestamp: ' . time();
        }
    }
    
    /**
     * @param string $section
     * @return string
     */
    protected function getSectionHeader($section) {
        switch ($section) {
            case self::SECTION_CACHE:
                return "CACHE:\n\n";
            case self::SECTION_NETWORK:
                return "NETWORK:\n\n";
            case self::SECTION_FALLBACK:
                return "FALLBACK:\n\n";
        }
    }
    
    /**
     * @param string $resource
     */
    protected function attachResourceToHash($resource) {
        $this->hashes .= md5_file($resource);
    }
    
    /**
     * @return bool
     */
    protected function manifestIsEmpty() {
        return (empty($this->cacheResources) 
                && empty($this->networkResources) 
                && empty($this->fallbackResources));
    }
    
    /**
     * @return bool
     */
    protected function fileIsValid($file, $dirs){
        return $file->isFile() 
                && $file->getFileName() != basename(__DIR__) 
                && substr(basename($dirs), 0, 1) != '.';
    }

}