<?php

class sfAsset extends BasesfAsset
{
   protected static $folders = array(); 

   protected $crop = null;

   public function __toString()
   {
      return $this->getFilename();
   }

   public function getImageCrop()
   {
      return $this->getCrop();
   }

   public function setCrop($crop)
   {
      $this->crop = $crop;
   }

   public function getCrop()
   {
      if (null === $this->crop)
      {
         $crop_file = $this->getFullPath().'.json';

         if (is_file($crop_file))
         {
            $this->crop = json_decode(file_get_contents($crop_file), true);  
         }
         else
         {
            $this->crop = array();
         }
      }

      return $this->crop;
   }

   public function getCropByImageType($type)
   {
      $crop = $this->getCrop();

      return isset($crop[$type]) ? $crop[$type] : array();
   }

   public function getsfAssetFolder($con = null)
   {
      if (isset(self::$folders[$this->folder_id]))
      {
         $this->setsfAssetFolder(self::$folders[$this->folder_id]);
      }
      else
      {
         self::$folders[$this->folder_id] = parent::getsfAssetFolder($con);
      }

      return parent::getsfAssetFolder($con);
   }

   public function getImageInfo()
   {
      return getimagesize($this->getFullPath());
   }

   public function getFilename($trim_ext = false)
   {
      $filename = parent::getFilename();

      if ($trim_ext)
      {
         $tmp = explode('.', $filename);

         $filename = $tmp[0];
      }

      return $filename;
   }

   /**
    * Get folder relative path
    *
    * @return string
    */
   public function getFolderPath()
   {
      $folder = $this->getsfAssetFolder();
      if (!$folder)
      {
         throw new Exception(sprintf('You must set define the folder for an asset prior to getting its path. Asset %d doesn\'t have a folder yet.', $this->getFilename()));
      }
      return $folder->getRelativePath();
   }

   public function countProductForSfAssets($criteria = null, $distinct = false, $con = null)
   {
      include_once 'lib/model/om/BaseProductForSfAssetPeer.php';
      if ($criteria === null)
      {
         $criteria = new Criteria();
      }
      elseif ($criteria instanceof Criteria)
      {
         $criteria = clone $criteria;
      }

      $criteria->add(ProductForSfAssetPeer::SF_ASSET_ID, $this->getId());

      return ProductForSfAssetPeer::doCount($criteria, $distinct, $con);
   }

   public function getPath()
   {
      $c = new Criteria();
      $c->add(sfAssetFolderPeer::ID, $this->getFolderId());

      $folder = sfAssetFolderPeer::doSelectOne($c);

      if ($folder)
      {

         return "/".$folder->getRelativePath()."/".$this->getFileName();
      }

      return "";
   }

   /**
    * Gives the file relative path
    *
    * @return string
    */
   public function getRelativePath()
   {
      return $this->getFolderPath().'/'.$this->getFilename();
   }

   public function setRawFilename($filename)
   {
      parent::setFilename($filename);
   }

   /**
    * Gives full filesystem path
    *
    * @param string $thumbnail_type
    * @return string
    */
   public function getFullPath($thumbnail_type = 'full')
   {
      return sfAssetsLibraryTools::getThumbnailPath($this->getFolderPath(), $this->getFilename(), $thumbnail_type);
   }

   public function setFilename($filename)
   {
      $filename = sfAssetsLibraryTools::sanitizeName($filename);

      return parent::setFilename($filename);
   }

   public function getFilesize($auto_format = false)
   {
      $filesize = parent::getFilesize();

      if ($auto_format)
      {
         if ($filesize < 1024)
         {
            return number_format($filesize, 1).' KB';
         }
         else
         {
            return number_format($filesize / 1024, 1).' MB';
         }
      }

      return $filesize;
   }

   /**
    * Gives the URL for the given thumbnail
    *
    * @param string $thumbnail_type
    * @return string
    */
   public function getUrl($thumbnail_type = 'full', $relative_path = null)
   {
      if (is_null($relative_path))
      {
         if (!$folder = $this->getsfAssetFolder())
         {
            throw new Exception(sprintf('You must set define the folder for an asset prior to getting its path. Asset %d doesn\'t have a folder yet.', $this->getFilename()));
         }
         $relative_path = $folder->getRelativePath();
      }
      $url = sfAssetsLibraryTools::getMediaDir();
      if ($thumbnail_type == 'full')
      {
         $url .= $relative_path.DIRECTORY_SEPARATOR.$this->getFilename();
      }
      else
      {
         $url .= sfAssetsLibraryTools::getThumbnailDir($relative_path).$thumbnail_type.'_'.$this->getFilename();
      }

      return sfAssetsLibraryTools::fixUrl($url);
   }

   public function autoSetType()
   {
      $this->setType(sfAssetsLibraryTools::getType($this->getFullPath()));
   }

   public function isImage()
   {
      $type = $this->getType();
      return $type == 'image' || $type == 'jpeg' || $type == 'jpg' || $type == 'png' || $type == 'gif';
   }

   public function supportsThumbnails()
   {
      return $this->isImage() && class_exists('sfThumbnail');
   }

   public function create($asset_path, $for = 'product', $move = true, $checkDuplicate = true)
   {
      if (!is_file($asset_path))
      {
         throw new sfAssetException('Asset "%asset%" not found', array('%asset%' => $asset_path));
      }

      // calculate asset properties
      if (!$this->getFilename())
      {
         list(, $filename) = sfAssetsLibraryTools::splitPath($asset_path);
         $this->setFilename($filename);
      }

      // check folder
      if (!$this->getsfAssetFolder()->exists())
      {
         $this->getsfAssetFolder()->create();
      }
   
      // check if a file with this name already exists
      if ($checkDuplicate && sfAssetPeer::exists($this->getsfAssetFolder()->getId(), $this->getFilename()))
      {
         $this->setFilename(uniqid().'-'.$this->getFilename());
      }
      
      $this->setFilesize(filesize($asset_path) / 1024);

      $this->autoSetType();

      $full_path = sfAssetsLibraryTools::fixPath($this->getFullPath());
      
      stJQueryToolsHelper::pluploadCopy(sfAssetsLibraryTools::fixPath($asset_path), $full_path, $move);

      $old = umask(0);

      chmod($full_path, 0644);

      umask($old);
   }

   public function getFilepaths($for, $with_full = true)
   {
      $filepaths = $with_full ? array('full' => $this->getFullPath()) : array();
      
      if ($this->isImage())
      {
         $config = stConfig::getInstance(null, 'stAsset');

         $thumbnails = $config->get($for, array());

         // Add path to the thumbnails
         foreach ($thumbnails as $key => $params)
         {
            $filepaths[$key] = $this->getFullPath($key);
         }
      }

      return $filepaths;
   }

   /**
    * Change asset directory and/or name
    *
    * @param sfAssetFolder $new_folder
    * @param string $new_filename
    */
   public function move(sfAssetFolder $new_folder, $new_filename = null, $for = 'product')
   {
      if (sfAssetPeer::exists($new_folder->getId(), $new_filename ? $new_filename : $this->getFilename()))
      {
         throw new sfAssetException('The target folder "%folder%" already contains an asset named "%name%". The asset has not been moved.', array('%folder%' => $new_folder, '%name%' => $new_filename ? $new_filename : $this->getFilename()));
      }

      $old_filepaths = $this->getFilepaths($for);

      if ($new_filename)
      {
         if (sfAssetsLibraryTools::sanitizeName($new_filename) != $new_filename)
         {
            throw new sfAssetException('The filename "%name%" contains incorrect characters. The asset has not be altered.', array('%name%' => $new_filename));
         }
         $this->setFilename($new_filename);
      }
      $this->setFolderId($new_folder->getId());

      $success = true;

      foreach ($old_filepaths as $type => $filepath)
      {
         if (file_exists(sfAssetsLibraryTools::fixPath($filepath)))
         {
            $success = rename(sfAssetsLibraryTools::fixPath($filepath), sfAssetsLibraryTools::fixPath($this->getFullPath($type))) && $success;
         }
      }

      if (!$success)
      {
         throw new sfAssetException('Some or all of the file operations failed. It is possible that the moved asset or its thumbnails are missing.');
      }
   }

   /**
    * Physically remove assets
    */
   public function destroy($for = 'product', $with_full = true)
   {
      $success = true;
      foreach ($this->getFilepaths($for, $with_full) as $filepath)
      {
         $filepath = sfAssetsLibraryTools::fixPath($filepath);

         if (!is_file($filepath))
            continue;

         $success = unlink($filepath) && $success;
      }

      return $success;
   }

   public function delete($con = null, $for = 'product')
   {
      $success = $this->destroy($for);

      $this->deleteCropFile();
      
      parent::delete($con);

      return $success;
   }

   public function deleteCropFile()
   {
      $crop_file = $this->getFullPath().'.json';

      if (is_file($crop_file))
      {
         unlink($crop_file);
      }     

      $this->setCrop(array()); 
   }

   public function updateCropFile()
   {
      $crop_file = $this->getFullPath().'.json';
      file_put_contents($crop_file, json_encode($this->getCrop()));      
   }

   public function save($con = null)
   {
      if ($this->getCrop()) 
      {
         $this->updateCropFile();
      }

      return parent::save($con);
   }

   public function getDescription()
   {
      if ($this->getCulture() == stLanguage::getOptLanguage())
      {
         return stLanguage::getDefaultValue($this, __METHOD__);
      }
      $v = parent::getDescription();
      if (is_null($v))
         $v = stLanguage::getDefaultValue($this, __METHOD__);
      return $v;
   }

   public function setDescription($v)
   {
      if ($this->getCulture() == stLanguage::getOptLanguage())
      {
         stLanguage::setDefaultValue($this, __METHOD__, $v);
      }

      parent::setDescription($v);
   }   

   public static function clearStaticPool()
   {
      self::$folders = array();
   }

}