/**
 * CSS Compat class
 * @author Aaron D Saray
 */
class cssCompat
{
    /**
     * used for determing type of file passed in
     * @var integer
     */
    const CSS_FILE = 1;
 
    /**
     * used for determining type of file passed in
     * @var integer
     */
    const MIXED_FILE = 2;
 
    /**
     * whether to print out files that are compatible?
     * @var boolean
     */
    const PRINT_OK_FILES = FALSE;
 
    /**
     * called multiple times tracker?
     * @var integer
     */
    protected $_timesProcessed = 0;
 
    /**
     * global tracker of incompats
     * @var integer
     */
    protected $_incompatCount = 0;
 
    /**
     * Available versions of browsers
     * @var array
     */
    protected $_available = array(
                                    'ff'=>array(2,3),
                                    'ie'=>array(6,7)
                                 );
 
    /**
     * The current browser version of the imported css
     * @var array
     */                                 
    protected $_current = array('browser'=>NULL, 'version'=>NULL);
 
    /**
     * The target version of the CSS to test for
     * @var array
     */
    protected $_target = array('browser'=>NULL, 'version'=>NULL);
 
    /**
     * the source css file to read in
     * @var string
     */
    protected $_sourceFile = '';
 
    /**
     * The type of file we're reading
     * @var integer
     */
    protected $_sourceFileType = 0;
 
    /**
     * The content to parse
     * @var mixed
     */
    protected $_content = FALSE;
 
    /**
     * css parts array of all the definitions
     * @var array
     */
    protected $_cssParts = array();
 
 
    /**
     * supported attributes - used for array diffing to find the items
     * list the items that are diff between the available versions
     * not a GREAT way to do this but...
     * @var array
     */
    protected $_supportedAttributes = array(
                                    'opacity'       => array('ff2', 'ff3'),
                                    '-moz-border'   => array('ff2', 'ff3'),
                                    'behavior'      => array('ie6', 'ie7'),
                                    'min-height'    => array('ff2', 'ff3'),
                                    'min-width'     => array('ff2', 'ff3'),
                                    'max-height'    => array('ff2', 'ff3'),
                                    'max-width'     => array('ff2', 'ff3')
                                  );
 
 
 
    ############################################################################
    ############################################################################
 
 
    /**
     * empty constructor...
     */
    public function __construct()
    {}
 
    /**
     * if more than one time, print the # of times called
     */
    public function __destruct()
    {
        if ($this->_timesProcessed > 1) {
            print "=============\nTotal Incompatibilities: {$this->_incompatCount}\n";
        }
    }
 
    /**
     * used to set the current browser version of the css
     * @param string $browser
     * @param integer $version
     */
    public function setCurrent($browser, $version)
    {
        if ($this->_isValidVersion($browser, $version)) {
            $this->_current['browser'] = $browser;
            $this->_current['version'] = $version;
            print "Setting current version to: {$browser} {$version}\n";
        }
    }
 
    /**
     * used to set the target browser version of the css
     * @param string $browser
     * @param integer $version
     */
    public function setTarget($browser, $version)
    {
        if ($this->_isValidVersion($browser, $version)) {
            $this->_target['browser'] = $browser;
            $this->_target['version'] = $version;
            print "Setting target version to: {$browser} {$version}\n";
        }
    }
 
    /**
     * set the source css file
     * @param string $file
     */
    public function setSourceFile($file)
    {
        if (is_readable($file)) {
            $this->_sourceFile = $file;
 
            $ext = '';
            $location = strrpos($file, '.');
            if ($location !== FALSE) {
                $ext = substr($file, $location+1);
            }
            if ($ext == 'css') {
                $this->setFileType(cssCompat::CSS_FILE);
            }
            else {
                $this->setFileType(cssCompat::MIXED_FILE);
            }
 
            $this->_content = file_get_contents($file);
            if ($this->_content === FALSE) {
                throw new exception("Unable to get contents of file: {$file}");
            }
        }
        else {
            throw new exception("{$file} is not readable.");
        }
    }
 
    /**
     * sets the file type to a css or non
     * @param integer $type The type of file
     */
    public function setFileType($type)
    {
        if ($type == self::CSS_FILE || $type == self::MIXED_FILE) {
            $this->_sourceFileType = $type;
        }
        else {
            throw new exception("Type {$type} is not a proper file type.");
        }
    }
 
    /**
     * starts processing the comparison
     */
    public function process()
    {
        $this->_timesProcessed++;
 
        $this->_checkProcessSanity();
 
        $this->_search();
    }
 
    ############################################################################
    ############################################################################
 
 
 
    /**
     * quick string searching alg for finding unsupported content
     */
    protected function _search()
    {
        $current = $this->_buildArray($this->_current['browser'], $this->_current['version']);
        $target = $this->_buildArray($this->_target['browser'], $this->_target['version']);
 
        $searchItems = array_diff($current, $target);
 
        $output = "Searching {$this->_sourceFile} (";
        switch ($this->_sourceFileType) {
            case self::CSS_FILE:
                $output .= "css";
                break;
            case self::MIXED_FILE:
                $output .= "mixed content";
                break;
        }
        $output .= " file)\n";
 
        $incompats = 0;
 
        $contentArray = $this->_getContent();
 
        foreach ($searchItems as $item) {
            $times = 0;
            foreach ($contentArray as $content) {
                $times += substr_count($content, $item);
            }
            if ($times) {
                $incompats += $times;
                $output .= "{$item} was found {$times} time" . ($times > 1 ? 's' : '') . "\n";
            }
        }
 
        if ($incompats || self::PRINT_OK_FILES) {
            print $output;
            print "Incompatibilities found: {$incompats}\n\n";
        }
 
        $this->_incompatCount += $incompats;
    }
 
    /**
     * returns the content to parse through
     * 
     * Either returns one result if its a css file
     * or if its mixed, goes through and looks for the "style" tag
     * 
     * @return array
     */
    protected function _getContent()
    {
        if ($this->_sourceFileType == cssCompat::CSS_FILE) {
            return array($this->_content);
        }
 
        /**
         * must be a mixed file type - so parse out the content of style tags
         */
        $return = array();
        preg_match_all("%<style\b[^>]*>(.*?)</style>|style\w*=['|\"](.*?)['|\"]%si", $this->_content, $matches);
 
        /** <style> **/
        if(isset($matches[1])) {
            foreach ($matches[1] as $content) {
                if (trim($content)) $return[] = trim($content);
            }
        }
 
        /** style="" **/
        if(isset($matches[2])) {
            foreach ($matches[2] as $content) {
                if (trim($content)) $return[] = trim($content);
            }
        }
 
        return $return;
    }
 
    /**
     * build an array of features for the requested browser/version
     * @param string $browser The browser
     * @param integer $version The version of the browser
     * @return array The combined array format
     */
    protected function _buildArray($browser, $version)
    {
        $key = $browser . $version;
        $return = array();
        foreach ($this->_supportedAttributes as $attribute=>$vals) {
            if (in_array($key, $vals)) {
                $return[] = $attribute;
            }
        }
 
        return $return;
    }
 
 
    /**
     * makes sure required items are set before continuing.
     */
    protected function _checkProcessSanity()
    {
        if (is_null($this->_current['browser']) || is_null($this->_current['version'])) {
            throw new exception("Current browser information needs to be set.");
        }
        if (is_null($this->_target['browser']) || is_null($this->_target['version'])) {
            throw new exception("Target browser information needs to be set.");
        }
        if ($this->_content === FALSE) {
            throw new exception("No content has been set.");
        }
    }
 
    /**
     * verifies that the browser / version are in the available list
     *
     * @param string $browser
     * @param integer $version
     * @return boolean
     */
    protected function _isValidVersion($browser, $version)
    {
        $b = strtolower($browser);
        if (!isset($this->_available[$b])) {
            throw new exception("{$browser} is not an available browser.");
            return false;
        }
 
        if (!in_array((int) $version, $this->_available[$b])) {
            throw new exception("{$version} is not a valid version of {$browser}");
            return false;
        }
 
        return true;
    }
}
 
try {
    /** file exts to allow **/
    $exts = array('css', 'html', 'htm', 'php', 'phtml', 'inc');
 
    /** ignore svn **/
    $ignore = '.svn';
 
    /** where to start **/
    $path = '/office';
 
    $css = new cssCompat();
 
    /** current and targets **/
    $css->setCurrent('ff', 2);
    $css->setTarget('ie', 7);
 
    /** now we do the loop **/
    $files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path));
    foreach($files as $name => $file) {
        if (strpos($name, $ignore) === false) {
            $parts = explode('.', $name);
            $ext = $parts[count($parts)-1];
            if (in_array($ext, $exts)) {
                $css->setSourceFile($name);
                $css->process();    
            }            
        }
 
    } 
}
catch (exception $e) {
    print $e->getMessage();
}