<?php
namespace W3TC;

/**
 * Manages data statistics.
 * Metrics:
 *
 */
class UsageStatistics_StorageWriter {
	private $slot_interval_seconds;
	private $slots_count;
	private $keep_history_interval_seconds;

	private $cache_storage;

	/**
	 * Cached values, just keep state between calls
	 */
	private $hotspot_endtime;
	private $new_hotspot_endtime = 0;
	private $now;

	/**
	 * begin_ sets the state what should it perform later
	 * finish reacts to that state and finishes flushing
	 * values:
	 *   not_needed - no flushinig required now
	 *   require_db - database access has to be available to decide
	 *   flushing_began_by_cache - that process has been selected to
	 *     flush hotspot data based on cache data state, still that has to be
	 *     verified in database
	 */
	private $flush_state;


	public function __construct() {
		$this->cache_storage = Dispatcher::get_usage_statistics_cache();

		$c = Dispatcher::config();
		$this->slot_interval_seconds = $c->get_integer( 'stats.slot_seconds' );

		$this->keep_history_interval_seconds =
			$c->get_integer( 'stats.slots_count' ) *
			$this->slot_interval_seconds;
		$this->slots_count = $c->get_integer( 'stats.slots_count' );
	}


	public function reset() {
		if ( !is_null( $this->cache_storage ) ) {
			$this->cache_storage->set( 'hotspot_endtime', 
			array( 'content' => 0 ) );
		}

		update_site_option( 'w3tc_stats_hotspot_start', time() );
		update_site_option( 'w3tc_stats_history', '' );
	}


	public function counter_add( $metric, $value ) {
		if ( !is_null( $this->cache_storage ) ) {
			$this->cache_storage->counter_add( $metric, $value );
		}
	}


	public function get_hotspot_end() {
		if ( is_null( $this->hotspot_endtime ) ) {
			$v = $this->cache_storage->get( 'hotspot_endtime' );
			$this->hotspot_endtime = ( isset( $v['content'] ) ? $v['content'] : 0 );
		}

		return $this->hotspot_endtime;
	}


	private function get_option_storage() {
		if ( is_multisite() )
			return new _OptionStorageWpmu();
		else
			return new _OptionStorageSingleSite();
	}


	public function maybe_flush_hotspot_data() {
		$result = $this->begin_flush_hotspot_data();
		if ( $result == 'not_needed' )
			return;

		$this->finish_flush_hotspot_data();
	}


	/**
	 * Returns if finish_* should be called.
	 * It tries to pass as litte processes as possible to
	 * flushing_begin if multiple processes come here
	 * at the same time when hotspot time ended.
	 */
	public function begin_flush_hotspot_data() {
		$hotspot_endtime = $this->get_hotspot_end();
		if ( is_null( $hotspot_endtime ) ) {
			// if cache not recognized - means nothing is cached at all
			// so stats not collected
			return 'not_needed';
		}

		$hotspot_endtime_int = (int)$hotspot_endtime;
		$this->now = time();

		if ( $hotspot_endtime_int <= 0 ) {
			$this->flush_state = 'require_db';
		} elseif ( $this->now < $hotspot_endtime_int ) {
			$this->flush_state = 'not_needed';
		} else {
			// rand value makes value unique for each process,
			// so as a result next replace works as a lock
			// passing only single process further
			$this->new_hotspot_endtime = $this->now + $this->slot_interval_seconds +
				( rand( 1, 9999 ) / 10000.0 );

			$succeeded = $this->cache_storage->set_if_maybe_equals( 'hotspot_endtime',
				array( 'content' => $hotspot_endtime ),
				array( 'content' => $this->new_hotspot_endtime ) );
			$this->flush_state =
				( $succeeded ? 'flushing_began_by_cache' : 'not_needed' );
		}

		return $this->flush_state;
	}


	public function finish_flush_hotspot_data() {
		$option_storage = $this->get_option_storage();

		if ( $this->flush_state == 'not_needed' )
			return;

		if ( $this->flush_state != 'require_db' &&
			$this->flush_state != 'flushing_began_by_cache' )
			throw new Exception( 'unknown usage stats state ' . $this->flush_state );

		// check whats there in db
		$this->hotspot_endtime = $option_storage->get_hotspot_end();
		$hotspot_endtime_int = (int)$this->hotspot_endtime;

		if ( $this->now < $hotspot_endtime_int ) {
			// update cache, since there is something old/missing in cache
			$this->cache_storage->set( 'hotspot_endtime',
				array( 'content' => $this->hotspot_endtime ) );
			return;   // not neeeded really, db state after
		}
		if ( $this->new_hotspot_endtime <= 0 )
			$this->new_hotspot_endtime = $this->now +
				$this->slot_interval_seconds +
				( rand( 1, 9999 ) / 10000.0 );

		if ( $hotspot_endtime_int <= 0 ) {
			// no data in options, initialization
			$this->cache_storage->set( 'hotspot_endtime',
				array( 'content' => $this->new_hotspot_endtime ) );
			update_site_option( 'w3tc_stats_hotspot_start', time() );
			$option_storage->set_hotspot_end( $this->new_hotspot_endtime );
			return;
		}

		// try to become the process who makes flushing by
		// performing atomic database update

		// rand value makes value unique for each process,
		// so as a result next replace works as a lock
		// passing only single process further
		$succeeded = $option_storage->prolong_hotspot_end(
			$this->hotspot_endtime, $this->new_hotspot_endtime );
		if ( !$succeeded )
			return;

		$this->cache_storage->set( 'hotspot_endtime',
			array( 'content' => $this->new_hotspot_endtime ) );


		// flush data
		$metrics = array();
		$metrics = apply_filters( 'w3tc_usage_statistics_metrics', $metrics );

		$metric_values = array();
		$metric_values['timestamp_start'] = get_site_option( 'w3tc_stats_hotspot_start' );
		$metric_values['timestamp_end'] = $hotspot_endtime_int;

		// try to limit time between get and reset of counter value
		// to loose as small as posssible
		foreach ( $metrics as $metric ) {
			$metric_values[$metric] = $this->cache_storage->counter_get( $metric );
			$this->cache_storage->counter_set( $metric, 0 );
		}

		$metric_values = apply_filters( 'w3tc_usage_statistics_metric_values',
			$metric_values );

		$history_encoded = get_site_option( 'w3tc_stats_history' );
		$history = null;
		if ( !empty( $history_encoded ) )
			$history = json_decode( $history_encoded, true );
		if ( !is_array( $history ) )
			$history = array();

		$time_keep_border = time() - $this->keep_history_interval_seconds;

		if ( $hotspot_endtime_int < $time_keep_border )
			$history = array(
				array(
					'timestamp_start' => $time_keep_border,
					'timestamp_end' => (int)$this->new_hotspot_endtime -
					$this->slot_interval_seconds - 1
				)
			);   // this was started too much time from now
		else {
			// add collected
			$history[] = $metric_values;

			// if we empty place later - fill it
			for ( ;; ) {
				$metric_values = array(
					'timestamp_start' => $metric_values['timestamp_end']
				);
				$metric_values['timestamp_end'] =
					$metric_values['timestamp_start'] + $this->slot_interval_seconds;
				if ( $metric_values['timestamp_end'] < $this->now )
					$history[] = $metric_values;
				else
					break;
			}

			// make sure we have at least one value in history
			for ( ;count( $history ) > $this->slots_count; ) {
				if ( !isset( $history[0]['timestamp_end'] ) ||
					$history[0]['timestamp_end'] < $time_keep_border )
					array_shift( $history );
				else
					break;
			}
		}

		$history = apply_filters(
			'w3tc_usage_statistics_history_set', $history );

		update_site_option( 'w3tc_stats_hotspot_start', $this->now );
		update_site_option( 'w3tc_stats_history', json_encode( $history ) );
	}
}


/**
 * Can update option by directly incrementing current value,
 * not via get+set operation
 */
class _OptionStorageSingleSite {
	private $option_hotspot_end = 'w3tc_stats_hotspot_end';


	public function get_hotspot_end() {
		global $wpdb;

		$row = $wpdb->get_row( $wpdb->prepare(
				'SELECT option_value ' .
				'FROM ' . $wpdb->options . ' ' .
				'WHERE option_name = %s LIMIT 1',
				$this->option_hotspot_end ) );

		if ( !is_object( $row ) )
			return false;

		$v = $row->option_value;
		return $v;
	}


	public function set_hotspot_end( $new_value ) {
		update_site_option( $this->option_hotspot_end, $new_value );
	}


	/**
	 * Performs atomic update of option value
	 * from old to new value. Makes sure that only single process updates it.
	 * Only single process gets true return value when multiple tries to do that.
	 */
	public function prolong_hotspot_end( $old_value, $new_value ) {
		global $wpdb;

		$q = $wpdb->prepare(
			'UPDATE ' . $wpdb->options . ' ' .
			'SET option_value = %s ' .
			'WHERE option_name = %s AND option_value = %s', $new_value,
			$this->option_hotspot_end, $old_value );

		$result = $wpdb->query( $q );
		$succeeded = ( $result > 0 );

		return $succeeded;
	}
}


/**
 * Can update option by directly incrementing current value,
 * not via get+set operation
 */
class _OptionStorageWpmu {
	private $option_hotspot_end = 'w3tc_stats_hotspot_end';


	public function get_hotspot_end() {
		global $wpdb;

		$row = $wpdb->get_row( $wpdb->prepare(
				'SELECT meta_value ' .
				'FROM ' . $wpdb->sitemeta . ' ' .
				'WHERE site_id = %d AND meta_key = %s',
				$wpdb->siteid, $this->option_hotspot_end ) );

		if ( !is_object( $row ) )
			return false;

		$v = $row->meta_value;
		return $v;
	}

	/**
	 * Performs atomic update of option value
	 * from old to new value. Makes sure that only single process updates it.
	 * Only single process gets true return value when multiple tries to do that.
	 */
	public function set_hotspot_end( $new_value ) {
		update_site_option( $this->option_hotspot_end, $new_value );
	}


	/**
	 * Performs atomic update of option value
	 * from old to new value. Makes sure that only single process updates it.
	 * Only single process gets true return value when multiple tries to do that.
	 */
	public function prolong_hotspot_end( $old_value, $new_value ) {
		global $wpdb;

		$result = $wpdb->query( $wpdb->prepare(
				'UPDATE ' . $wpdb->sitemeta . ' ' .
				'SET meta_value = %s ' .
				'WHERE site_id = %d AND meta_key = %s AND meta_value = %s',
				$new_value, $wpdb->siteid, $this->option_hotspot_end, $old_value ) );
		$succeeded = ( $result > 0 );

		return $succeeded;
	}
}