<?php

/**
 * A repository for files accessible via InstantCommons. 
 */

class ICRepo extends LocalRepo {
	var $directory, $url, $hashLevels, $cache;	
	var $fileFactory = array( 'ICFile', 'newFromTitle' );
	var $oldFileFactory = false;

	function __construct( $info ) {
		parent::__construct( $info );		
		// Required settings
		$this->directory = $info['directory'];
		$this->url = $info['url'];
		$this->hashLevels = $info['hashLevels'];
		if(isset($info['cache'])){
			$this->cache = getcwd().'/images/'.$info['cache'];
		}		
	}		
}

/**
 * A file loaded from InstantCommons
 */
class ICFile extends LocalFile{
	static function newFromTitle($title,$repo){
		return new self($title, $repo);		
	}
	
	/**
	 * Returns true if the file comes from the local file repository.
	 *
	 * @return bool
	 */
	function isLocal() { 
		return true; 
	}
		
	function load(){
		if (!$this->dataLoaded ) {
			if ( !$this->loadFromCache() ) {
				if(!$this->loadFromDB()){
					$this->loadFromIC();
				}				
				$this->saveToCache(); 
			}
			$this->dataLoaded = true;
		}		
	}
	
	/**
	 * Load file metadata from the DB
	 */
	function loadFromDB() {
		wfProfileIn( __METHOD__ );

		# Unconditionally set loaded=true, we don't want the accessors constantly rechecking
		$this->dataLoaded = true;

		$dbr = $this->repo->getSlaveDB();

		$row = $dbr->selectRow( 'ic_image', $this->getCacheFields( 'img_' ),
			array( 'img_name' => $this->getName() ), __METHOD__ ); 
		if ( $row ) {
			if (trim($row->img_media_type)==NULL) {
				$this->upgradeRow();
				$this->upgraded = true;
			} 
			$this->loadFromRow( $row );
			//This means that these files are local so the repository locations are local
			$this->setUrlPathLocal();			
			$this->fileExists = true;
			//var_dump($this); exit;
		} else {
			$this->fileExists = false;
		}

		wfProfileOut( __METHOD__ );
		
		return $this->fileExists;
	}
	
		/**
	 * Fix assorted version-related problems with the image row by reloading it from the file
	 */
	function upgradeRow() {
		wfProfileIn( __METHOD__ );

		$this->loadFromIC();

		$dbw = $this->repo->getMasterDB();
		list( $major, $minor ) = self::splitMime( $this->mime );

		wfDebug(__METHOD__.': upgrading '.$this->getName()." to the current schema\n");

		$dbw->update( 'ic_image',
			array(
				'img_width' => $this->width,
				'img_height' => $this->height,
				'img_bits' => $this->bits,
				'img_media_type' => $this->type,
				'img_major_mime' => $major,
				'img_minor_mime' => $minor,
				'img_metadata' => $this->metadata,
			), array( 'img_name' => $this->getName() ),
			__METHOD__
		);
		$this->saveToCache();
		wfProfileOut( __METHOD__ );
	}
	
	function exists(){
		$this->load();
		return $this->fileExists;
		
	}
	
	/**
	 * Fetch the file from the repository. Check local ic_images table first. If not available, check remote server
	 */	 
	 function loadFromIC(){
	 	# Unconditionally set loaded=true, we don't want the accessors constantly rechecking
		$this->dataLoaded = true;
		$icUrl = $this->repo->directory.'&media='.$this->title->mDbkeyform; 
		if($h = @fopen($icUrl, 'rb')){		 	
		 	$contents = fread($h, 3000);
		 	$image = $this->api_xml_to_array($contents);
		 	if($image['fileExists']){
		 		foreach($image as $property=>$value){
		 			if($property=="url"){$value=$this->repo->url.$value; }	 			
		 			$this->$property = $value;
		 		}  
				 if($this->curl_file_get_contents($this->repo->url.$image['url'], $this->repo->cache.'/'.$image['name'])){
				 	//Record the image	
				 	$this->recordDownload("Downloaded with InstantCommons");
	            	
				 	//Then cache it			 			 	
				 }else{//set fileExists back to false			 	
				 	$this->fileExists = false;
				 }			 
		 	}
		}
	 }
	 
	
	 function setUrlPathLocal(){
	 	global $wgScriptPath;
	 	$path = $wgScriptPath.'/'.substr($this->repo->cache, strlen($wgScriptPath));
	 	$this->repo->url = $path;//.'/'.rawurlencode($this->title->mDbkeyform);		
		$this->repo->directory = $this->repo->cache;//.'/'.rawurlencode($this->title->mDbkeyform);
	 	
	 }
	
	 function getThumbPath( $suffix=false ){
	 	$path = $this->repo->cache;
	 	if ( $suffix !== false ) {
			$path .= '/thumb/' . rawurlencode( $suffix );
		}
		return $path;
	 }
	 function getThumbUrl( $suffix=false ){
	 	global $wgScriptPath;
	 	$path = $wgScriptPath.'/'.substr($this->repo->cache, strlen($wgScriptPath));
	 	if ( $suffix !== false ) {
			$path .= '/thumb/' . rawurlencode( $suffix );
		}
		return $path;
	 }
	
	 /**
	  * Convert the InstantCommons Server API XML Response to an associative array
	  */
	  function api_xml_to_array($xml){
		 preg_match("/<instantcommons><image(.*?)<\/instantcommons>/",$xml,$match);
		 preg_match_all("/(.*?=\".*?\")/",$match[1], $matches);
		 foreach($matches[1] as $match){
		 	list($key,$value) = split("=",$match);
		 	$image[trim($key,'<" ')]=trim($value,' "');
		 }	
		 return $image;
	  }
	  
	/**
     * Use cURL to read the content of a URL into a string
     * ref: http://groups-beta.google.com/group/comp.lang.php/browse_thread/thread/8efbbaced3c45e3c/d63c7891cf8e380b?lnk=raot
     * @param string $url - the URL to fetch
     * @param resource $fp - filename to write file contents to
     * @param boolean $bg - call cURL in the background (don't hang page until complete)
     * @param int $timeout - cURL connect timeout
     */
    function curl_file_get_contents($url, $fp, $bg=TRUE, $timeout = 1) {
        {
        	# Call curl in the background to download the file
	        $cmd = 'curl '.wfEscapeShellArg($url).' -o '.$fp.' &';
	        wfDebug('Curl download initiated='.$cmd );
	        $success = false;  
        	$file_contents = array();        	         
            $file_contents['err'] = wfShellExec($cmd, $file_contents['return']);
            if($file_contents['err']==0){//Success
            	$success = true;
            }                
        }
       return $success;                
    }
	
	function getMasterDB() {
		if ( !isset( $this->dbConn ) ) {
			$class = 'Database' . ucfirst( $this->dbType );
			$this->dbConn = new $class( $this->dbServer, $this->dbUser, 
				$this->dbPassword, $this->dbName, false, $this->dbFlags, 
				$this->tablePrefix );
		}
		return $this->dbConn;
	}

	/**
	 * Record a file upload in the upload log and the image table
	 */
	private function recordDownload($comment='', $timestamp = false ){
		global $wgUser; 

		$dbw = $this->repo->getMasterDB();
		
		if ( $timestamp === false ) {
			$timestamp = $dbw->timestamp();
		}
		list( $major, $minor ) = self::splitMime( $this->mime );

		# Test to see if the row exists using INSERT IGNORE
		# This avoids race conditions by locking the row until the commit, and also
		# doesn't deadlock. SELECT FOR UPDATE causes a deadlock for every race condition.
		$dbw->insert( 'ic_image',
			array(
				'img_name' => $this->getName(),
				'img_size'=> $this->size,
				'img_width' => intval( $this->width ),
				'img_height' => intval( $this->height ),
				'img_bits' => $this->bits,
				'img_media_type' => $this->type,
				'img_major_mime' => $major,
				'img_minor_mime' => $minor,
				'img_timestamp' => $timestamp,
				'img_description' => $comment,
				'img_user' => $wgUser->getID(),
				'img_user_text' => $wgUser->getName(),
				'img_metadata' => $this->metadata,
			),
			__METHOD__,
			'IGNORE'
		);

		if( $dbw->affectedRows() == 0 ) {
			# Collision, this is an update of a file			
			# Update the current image row
			$dbw->update( 'ic_image',
				array( /* SET */
					'img_size' => $this->size,
					'img_width' => intval( $this->width ),
					'img_height' => intval( $this->height ),
					'img_bits' => $this->bits,
					'img_media_type' => $this->media_type,
					'img_major_mime' => $this->major_mime,
					'img_minor_mime' => $this->minor_mime,
					'img_timestamp' => $timestamp,
					'img_description' => $comment,
					'img_user' => $wgUser->getID(),
					'img_user_text' => $wgUser->getName(),
					'img_metadata' => $this->metadata,
				), array( /* WHERE */
					'img_name' => $this->getName()
				), __METHOD__
			);
		} else {
			# This is a new file
			# Update the image count
			$site_stats = $dbw->tableName( 'site_stats' );
			$dbw->query( "UPDATE $site_stats SET ss_images=ss_images+1", __METHOD__ );
		}

		$descTitle = $this->getTitle();
		$article = new Article( $descTitle );

		# Add the log entry
		$log = new LogPage( 'icdownload' );
		$log->addEntry( 'InstantCommons download', $descTitle, $comment );

		if( $descTitle->exists() ) {
			# Create a null revision
			$nullRevision = Revision::newNullRevision( $dbw, $descTitle->getArticleId(), $log->getRcComment(), false );
			$nullRevision->insertOn( $dbw );
			$article->updateRevisionOn( $dbw, $nullRevision );

			# Invalidate the cache for the description page
			$descTitle->invalidateCache();
			$descTitle->purgeSquid();
		}

		
		# Commit the transaction now, in case something goes wrong later
		# The most important thing is that files don't get lost, especially archives
		$dbw->immediateCommit();

		# Invalidate cache for all pages using this file
		$update = new HTMLCacheUpdate( $this->getTitle(), 'imagelinks' );
		$update->doUpdate();

		return true;
	}
	
}