<?php
  /*********************************************************************************************************************

      MESSAGE FROM THE PLUGIN AUTHOR
      ==============================

      THIS SCRIPT IS NOT !!! USED IN THE CURRENT VERSIONS OF THE PLUGIN.
      IT IS KEPT HERE AS A COMPATIBILITY MODE FOR USERS WHO HAVE VERSIONS PRIOR TO 0.5.0.
      SINCE VERSION 0.5.0 THE PLUGIN DOES NOT USE THIS SCRIPT AT ALL.
      THE REASON IS THE CC-BY-3.0 TO GPL INCOMPATIBILITY.

      NEVMA
      =====

   ********************************************************************************************************************/



  /* 
    PROJECT INFO
    Version   : 1.5.2
    Changelog : http://adaptive-images.com/changelog.txt

    Homepage  : http://adaptive-images.com
    GitHub    : https://github.com/MattWilcox/Adaptive-Images
    Twitter   : @responsiveimg

    LEGAL     : Adaptive Images by Matt Wilcox is licensed under a Creative Commons Attribution 3.0 Unported License.
  */



  /*
    THE FOLLOWING ARE DEFAULT VALUES WHICH CAN BE OVERRIDEN IN THE ADMIN. 
    DO NOT, I REPEAT, DO NOT OVERRIDE THEM HERE UNLESS YOU REALLY KNOW WHAT YOU ARE DOING.
  */

  // the resolution breakpoints of screens widths in pixels
  $resolutions = array( 1024, 600, 480 ); 

  // where to store the generated resized images
  $cache_dir = "cache-ai";

  // the quality of any generated JPGs (from 0 to 100)
  $jpg_quality = 65;

  // perform a sharpen on rescaled images to reduce blur
  $sharpen = TRUE;

  // check that a resized image isn't stale 
  $watch_cache = TRUE;

  // how long the browser cache should last (s*m*h*d)
  $browser_cache = 60*60*24*7;



  // Nevma -->>

  // Include user defined settings from WP admin, if any.
  if ( file_exists( realpath( dirname( $_SERVER['SCRIPT_FILENAME'] ) . '/ai-user-settings.php' ) ) ) {

    include( 'ai-user-settings.php' );

  }

  // <<-- Nevma 



  /* get all of the required data from the HTTP request */

  // set the document root to the /wp-content folder
  $document_root  = realpath( dirname( $_SERVER['SCRIPT_FILENAME'] ) . '/../../../' );
  $requested_uri  = parse_url(urldecode($_SERVER['REQUEST_URI']), PHP_URL_PATH);
  $requested_file = basename($requested_uri);
  $source_file    = $_SERVER['DOCUMENT_ROOT'].$requested_uri;
  $resolution     = FALSE;



  // Nevma -->>

  // Debugging information.

  if ( isset( $_GET['debug'] ) ) {

    if ( $_GET['debug'] == 'true' ) {

      $image_info = @GetImageSize( $source_file );

      header("Content-Type: text/plain" ); ?>



                                    ADAPTIVE IMAGES DEBUG



      #######################################################################################



      Script status
      =============

      Seeing this means the plugin is running and that the .htaccess is setup alright!

      Cookie         : <?php echo $_COOKIE['resolution']; ?> 
      Cache writable : <?php echo is_writable( $document_root . '/' . $cache_dir ) ? 'YES' : 'NO'; ?> 



      User settings
      =============

      $resolutions   : <?php echo implode( ',', $resolutions ); ?> 
      $cache_dir     : <?php echo $cache_dir; ?> 
      $jpg_quality   : <?php echo $jpg_quality; ?> 
      $sharpen       : <?php echo $sharpen ? 'TRUE' : 'FALSE'; ?> 
      $watch_cache   : <?php echo $watch_cache ? 'TRUE' : 'FALSE'; ?> 
      $browser_cache : <?php echo $browser_cache; ?> 



      Image requested
      ===============

      Image      : <?php echo $requested_uri; ?> 
      Exists     : <?php echo file_exists( $source_file ) ? 'YES' : 'NO' ?> 
      Mime       : <?php echo file_exists( $source_file ) ? $image_info['mime'] : '-'; ?> 
      Dimensions : <?php echo file_exists( $source_file ) ? $image_info[0] . 'x' . $image_info[1] : '-'; ?> 
      Size       : <?php echo file_exists( $source_file ) ? filesize( $source_file ) : '-'; ?> 



      ---------------------------------------------------------------------------------------

      You are viewing this page instead of the image you requested.
      This is part of the debugging facilities of the Adaptive Images plugin.
      Just remove the "?debug=true" part in your url above in order to simply see your image. 
      Add a "?debug=original" to see the original image before being resized. <?php 

      exit();

    } elseif ( $_GET['debug'] == 'original' ) {

      sendImage( $source_file, $browser_cache );

      exit();

    }

  }

  // <<-- Nevma 



  /* Mobile detection 
     NOTE: only used in the event a cookie isn't available. */
  function is_mobile() {
    $userAgent = strtolower($_SERVER['HTTP_USER_AGENT']);
    return strpos($userAgent, 'mobile');
  }

  /* Does the UA string indicate this is a mobile? */
  if(!is_mobile()){
    $is_mobile = FALSE;
  } else {
    $is_mobile = TRUE;
  }

  // does the $cache_dir directory exist already?
  if (!is_dir("$document_root/$cache_dir")) { // no
    if (!mkdir("$document_root/$cache_dir", 0755, true)) { // so make it
      if (!is_dir("$document_root/$cache_dir")) { // check again to protect against race conditions
        // uh-oh, failed to make that directory
        sendErrorImage("Failed to create cache directory at: $document_root/$cache_dir");
      }
    }
  }

  /* helper function: Send headers and returns an image. */
  function sendImage($filename, $browser_cache) {
    $extension = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
    if (in_array($extension, array('png', 'gif', 'jpeg'))) {
      header("Content-Type: image/".$extension);
    } else {
      header("Content-Type: image/jpeg");
    }

    // Nevma -->>

    // If plugin browser cache is set to zero then do nothing, so that the default settings will take effect.
    if ( $browser_cache > 0 ) {
      header("Cache-Control: private, max-age=".$browser_cache);
      header('Expires: '.gmdate('D, d M Y H:i:s', time()+$browser_cache).' GMT');
    }

    // Add last modified cache header.
    header( 'Last-Modified: ' . gmdate( 'D, d M Y H:i:s', filemtime( $filename ) ) . ' GMT' );

    // <<-- Nevma 

    header('Content-Length: '.filesize($filename));
    readfile($filename);
    exit();
  }

  /* helper function: Create and send an image with an error message. */
  function sendErrorImage($message) {
    /* get all of the required data from the HTTP request */
    $document_root  = $_SERVER['DOCUMENT_ROOT'];
    $requested_uri  = parse_url(urldecode($_SERVER['REQUEST_URI']), PHP_URL_PATH);
    $requested_file = basename($requested_uri);
    $source_file    = $document_root.$requested_uri;

    if(!is_mobile()){
      $is_mobile = "FALSE";
    } else {
      $is_mobile = "TRUE";
    }

    $im            = ImageCreateTrueColor(800, 300);
    $text_color    = ImageColorAllocate($im, 233, 14, 91);
    $message_color = ImageColorAllocate($im, 91, 112, 233);

    ImageString($im, 5, 5, 5, "Adaptive Images encountered a problem:", $text_color);
    ImageString($im, 3, 5, 25, $message, $message_color);

    ImageString($im, 5, 5, 85, "Potentially useful information:", $text_color);
    ImageString($im, 3, 5, 105, "DOCUMENT ROOT IS: $document_root", $text_color);
    ImageString($im, 3, 5, 125, "REQUESTED URI WAS: $requested_uri", $text_color);
    ImageString($im, 3, 5, 145, "REQUESTED FILE WAS: $requested_file", $text_color);
    ImageString($im, 3, 5, 165, "SOURCE FILE IS: $source_file", $text_color);
    ImageString($im, 3, 5, 185, "DEVICE IS MOBILE? $is_mobile", $text_color);

    header("Cache-Control: no-store");
    header('Expires: '.gmdate('D, d M Y H:i:s', time()-1000).' GMT');
    header('Content-Type: image/jpeg');
    ImageJpeg($im);
    ImageDestroy($im);
    exit();
  }

  /* sharpen images function */
  function findSharp($intOrig, $intFinal) {
    $intFinal = $intFinal * (750.0 / $intOrig);
    $intA     = 52;
    $intB     = -0.27810650887573124;
    $intC     = .00047337278106508946;
    $intRes   = $intA + $intB * $intFinal + $intC * $intFinal * $intFinal;
    return max(round($intRes), 0);
  }

  /* refreshes the cached image if it's outdated */
  function refreshCache($source_file, $cache_file, $resolution) {
    if (file_exists($cache_file)) {
      // not modified
      if (filemtime($cache_file) >= filemtime($source_file)) {
        return $cache_file;
      }

      // modified, clear it
      unlink($cache_file);
    }
    return generateImage($source_file, $cache_file, $resolution);
  }

  /* generates the given cache file for the given source file with the given resolution */
  function generateImage($source_file, $cache_file, $resolution) {
    global $sharpen, $jpg_quality;

    $extension = strtolower(pathinfo($source_file, PATHINFO_EXTENSION));

    // Check the image dimensions
    $dimensions   = GetImageSize($source_file);
    $width        = $dimensions[0];
    $height       = $dimensions[1];

    // Do we need to downscale the image?
    if ($width <= $resolution) { // no, because the width of the source image is already less than the client width
      return $source_file;
    }

    // We need to resize the source image to the width of the resolution breakpoint we're working with
    $ratio      = $height/$width;
    $new_width  = $resolution;
    $new_height = ceil($new_width * $ratio);
    $dst        = ImageCreateTrueColor($new_width, $new_height); // re-sized image

    switch ($extension) {
      case 'png':
        $src = @ImageCreateFromPng($source_file); // original image
      break;
      case 'gif':
        $src = @ImageCreateFromGif($source_file); // original image
      break;
      default:
        $src = @ImageCreateFromJpeg($source_file); // original image
        ImageInterlace($dst, true); // Enable interlancing (progressive JPG, smaller size file)
      break;
    }

    if($extension=='png'){

      // Nevma -->>

      // OLD

      // imagealphablending($dst, false);
      // imagesavealpha($dst,true);
      // $transparent = imagecolorallocatealpha($dst, 255, 255, 255, 127);
      // imagefilledrectangle($dst, 0, 0, $new_width, $new_height, $transparent);

      // NEW

      // As specified in http://stackoverflow.com/questions/5752514/how-to-convert-png-to-8-bit-png-using-php-gd-library
      $rbga = imagecolorallocatealpha($dst, 0, 0, 0, 127);
      imagecolortransparent($dst, $rbga);
      imagefill($dst, 0, 0, $rbga);
      imagecopy($dst, $src, 0, 0, 0, 0, $new_width, $new_height);
      imagetruecolortopalette($dst, false, 255);
      // imagealphablending($dst, false);
      imagesavealpha($dst, true);

      // <<-- Nevma 
      
    }
    
    ImageCopyResampled($dst, $src, 0, 0, 0, 0, $new_width, $new_height, $width, $height); // do the resize in memory
    ImageDestroy($src);

    // sharpen the image?
    // NOTE: requires PHP compiled with the bundled version of GD (see http://php.net/manual/en/function.imageconvolution.php)
    if($sharpen == TRUE && function_exists('imageconvolution')) {
      $intSharpness = findSharp($width, $new_width);
      $arrMatrix = array(
        array(-1, -2, -1),
        array(-2, $intSharpness + 12, -2),
        array(-1, -2, -1)
      );
      imageconvolution($dst, $arrMatrix, $intSharpness, 0);
    }

    $cache_dir = dirname($cache_file);

    // does the directory exist already?
    if (!is_dir($cache_dir)) { 
      if (!mkdir($cache_dir, 0755, true)) {
        // check again if it really doesn't exist to protect against race conditions
        if (!is_dir($cache_dir)) {
          // uh-oh, failed to make that directory
          ImageDestroy($dst);
          sendErrorImage("Failed to create cache directory: $cache_dir");
        }
      }
    }

    if (!is_writable($cache_dir)) {
      sendErrorImage("The cache directory is not writable: $cache_dir");
    }

    // save the new file in the appropriate path, and send a version to the browser
    switch ($extension) {
      case 'png':
        $gotSaved = ImagePng($dst, $cache_file);
      break;
      case 'gif':
        $gotSaved = ImageGif($dst, $cache_file);
      break;
      default:
        $gotSaved = ImageJpeg($dst, $cache_file, $jpg_quality);
      break;
    }
    ImageDestroy($dst);

    if (!$gotSaved && !file_exists($cache_file)) {
      sendErrorImage("Failed to create image: $cache_file");
    }

    return $cache_file;
  }

  //=====================================================================================================================

  // check if the file exists at all
  if (!file_exists($source_file)) {
    header("Status: 404 Not Found");
    exit();
  }

  /* check that PHP has the GD library available to use for image re-sizing */
  if (!extension_loaded('gd')) { // it's not loaded
    if (!function_exists('dl') || !dl('gd.so')) { // and we can't load it either
      // no GD available, so deliver the image straight up
      trigger_error('You must enable the GD extension to make use of Adaptive Images', E_USER_WARNING);
      sendImage($source_file, $browser_cache);
    }
  }

  /* Check to see if a valid cookie exists */
  if (isset($_COOKIE['resolution'])) {
    $cookie_value = $_COOKIE['resolution'];

    // does the cookie look valid? [whole number, comma, potential floating number]
    if (! preg_match("/^[0-9]+[,]*[0-9\.]+$/", "$cookie_value")) 
    { 
      // no it doesn't look valid
      setcookie("resolution", "$cookie_value", time()-100); // delete the mangled cookie
    }
    else 
    { 
      // the cookie is valid, do stuff with it
      $cookie_data   = explode(",", $_COOKIE['resolution']);
      $client_width  = (int) $cookie_data[0]; // the base resolution (CSS pixels)

      $total_width   = $client_width;
      $pixel_density = 1; // set a default, used for non-retina style JS snippet
      if (@$cookie_data[1]) { // the device's pixel density factor (physical pixels per CSS pixel)
        $pixel_density = $cookie_data[1];
      }

      rsort($resolutions); // make sure the supplied break-points are in reverse size order
      $resolution = $resolutions[0]; // by default use the largest supported break-point

      // if pixel density is not 1, then we need to be smart about adapting and fitting into the defined breakpoints
      if($pixel_density != 1) {
        $total_width = $client_width * $pixel_density; // required physical pixel width of the image

        // the required image width is bigger than any existing value in $resolutions
        if($total_width > $resolutions[0]){
          // firstly, fit the CSS size into a break point ignoring the multiplier
          foreach ($resolutions as $break_point) { // filter down
            if ($total_width <= $break_point) {
              $resolution = $break_point;
            }
          }
          // now apply the multiplier
          $resolution = $resolution * $pixel_density;
        }
        // the required image fits into the existing breakpoints in $resolutions
        else {
          foreach ($resolutions as $break_point) { // filter down
            if ($total_width <= $break_point) {
              $resolution = $break_point;
            }
          }
        }
      }
      else { // pixel density is 1, just fit it into one of the breakpoints
        foreach ($resolutions as $break_point) { // filter down
          if ($total_width <= $break_point) {
            $resolution = $break_point;
          }
        }
      }

      // Nevma -->>
      $image_info = @GetImageSize( $source_file );
      $image_width = $image_info[0];

      // var_dump( 'Total width: ' . $total_width );
      // echo '<br/>';
      // var_dump( 'Image width:' . $image_width );
      // echo '<br/>';
      // var_dump( 'Resolution: ' . $resolution );

      // If orginal image width and device screen are both bigger than the biggest breakpoint.

      if ( $image_width > $resolution && $total_width > $resolution ) { 

        // Then send the original image itself as the best solution.
        sendImage( $source_file, $browser_cache );

      }
      // <<-- Nevma

    }
  }

  /* No resolution was found (no cookie or invalid cookie) */
  if (!$resolution) {
    // We send the lowest resolution for mobile-first approach, and highest otherwise
    
    // Nevma -->>

    // Original code:
    // $resolution = $is_mobile ? min($resolutions) : max($resolutions);

    // But we want to send the original file when there is no cookie, so:
    sendImage( $source_file, $browser_cache );

    // <<-- Nevma
  }

  /* if the requested URL starts with a slash, remove the slash */
  if(substr($requested_uri, 0,1) == "/") {
    $requested_uri = substr($requested_uri, 1);
  }

  /* whew might the cache file be? */
  $cache_file = $document_root."/$cache_dir/$resolution/".$requested_uri;

  $image_info = @GetImageSize($source_file);

  /* Use the resolution value as a path variable and check to see if an image of the same name exists at that path */
  if (file_exists($cache_file)) { // it exists cached at that size
    if ($watch_cache) { // if cache watching is enabled, compare cache and source modified dates to ensure the cache isn't stale
      $cache_file = refreshCache($source_file, $cache_file, $resolution);
    }

    sendImage($cache_file, $browser_cache);
  }

  /* It exists as a source file, and it doesn't exist cached - lets make one: */
  $file = generateImage($source_file, $cache_file, $resolution);
  sendImage($file, $browser_cache);

?>