<?php
/**
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 * http://www.gnu.org/copyleft/gpl.html
 *
 * @file
 */

use MediaWiki\Cache\LinkBatchFactory;
use MediaWiki\MediaWikiServices;
use Wikimedia\Timestamp\TimestampException;

class ImageHistoryPseudoPager extends ReverseChronologicalPager {
	protected $preventClickjacking = false;

	/**
	 * @var File
	 */
	protected $mImg;

	/**
	 * @var Title
	 */
	protected $mTitle;

	/**
	 * @since 1.14
	 * @var ImagePage
	 */
	public $mImagePage;

	/**
	 * @since 1.14
	 * @var File[]
	 */
	public $mHist;

	/**
	 * @since 1.14
	 * @var int[]
	 */
	public $mRange;

	/** @var LinkBatchFactory */
	private $linkBatchFactory;

	/**
	 * @param ImagePage $imagePage
	 * @param LinkBatchFactory|null $linkBatchFactory
	 */
	public function __construct( $imagePage, LinkBatchFactory $linkBatchFactory = null ) {
		parent::__construct( $imagePage->getContext() );
		$this->mImagePage = $imagePage;
		$this->mTitle = $imagePage->getTitle()->createFragmentTarget( 'filehistory' );
		$this->mImg = null;
		$this->mHist = [];
		$this->mRange = [ 0, 0 ]; // display range

		// Only display 10 revisions at once by default, otherwise the list is overwhelming
		$this->mLimitsShown = array_merge( [ 10 ], $this->mLimitsShown );
		$this->mDefaultLimit = 10;
		list( $this->mLimit, /* $offset */ ) =
			$this->mRequest->getLimitOffsetForUser(
				$this->getUser(),
				$this->mDefaultLimit,
				''
			);
		$this->linkBatchFactory = $linkBatchFactory ?? MediaWikiServices::getInstance()->getLinkBatchFactory();
	}

	/**
	 * @return Title
	 */
	public function getTitle() {
		return $this->mTitle;
	}

	public function getQueryInfo() {
		return [];
	}

	/**
	 * @return string
	 */
	public function getIndexField() {
		return '';
	}

	/**
	 * @param stdClass $row
	 * @return string
	 */
	public function formatRow( $row ) {
		return '';
	}

	/**
	 * @return string
	 */
	public function getBody() {
		$s = '';
		$this->doQuery();
		if ( count( $this->mHist ) ) {
			if ( $this->mImg->isLocal() ) {
				// Do a batch existence check for user pages and talkpages
				$linkBatch = $this->linkBatchFactory->newLinkBatch();
				for ( $i = $this->mRange[0]; $i <= $this->mRange[1]; $i++ ) {
					$file = $this->mHist[$i];
					$uploader = $file->getUploader( File::FOR_THIS_USER, $this->getAuthority() );
					if ( $uploader ) {
						$linkBatch->add( NS_USER, $uploader->getName() );
						$linkBatch->add( NS_USER_TALK, $uploader->getName() );
					}
				}
				$linkBatch->execute();
			}

			$list = new ImageHistoryList( $this->mImagePage );
			# Generate prev/next links
			$navLink = $this->getNavigationBar();
			$s = $list->beginImageHistoryList( $navLink );
			// Skip rows there just for paging links
			for ( $i = $this->mRange[0]; $i <= $this->mRange[1]; $i++ ) {
				$file = $this->mHist[$i];
				$s .= $list->imageHistoryLine( !$file->isOld(), $file );
			}
			$s .= $list->endImageHistoryList( $navLink );

			if ( $list->getPreventClickjacking() ) {
				$this->preventClickjacking();
			}
		}
		return $s;
	}

	public function doQuery() {
		if ( $this->mQueryDone ) {
			return;
		}
		$this->mImg = $this->mImagePage->getPage()->getFile(); // ensure loading
		if ( !$this->mImg->exists() ) {
			return;
		}
		// Make sure the date (probably from user input) is valid; if not, drop it.
		if ( $this->mOffset !== null ) {
			try {
				$sadlyWeCannotPassThisTimestampDownTheStack = $this->mDb->timestamp( $this->mOffset );
			} catch ( TimestampException $e ) {
				$this->mOffset = null;
			}
		}
		$queryLimit = $this->mLimit + 1; // limit plus extra row
		if ( $this->mIsBackwards ) {
			// Fetch the file history
			$this->mHist = $this->mImg->getHistory( $queryLimit, null, $this->mOffset, false );
			// The current rev may not meet the offset/limit
			$numRows = count( $this->mHist );
			if ( $numRows <= $this->mLimit && $this->mImg->getTimestamp() > $this->mOffset ) {
				$this->mHist = array_merge( [ $this->mImg ], $this->mHist );
			}
		} else {
			// The current rev may not meet the offset
			if ( !$this->mOffset || $this->mImg->getTimestamp() < $this->mOffset ) {
				$this->mHist[] = $this->mImg;
			}
			// Old image versions (fetch extra row for nav links)
			$oiLimit = count( $this->mHist ) ? $this->mLimit : $this->mLimit + 1;
			// Fetch the file history
			$this->mHist = array_merge( $this->mHist,
				$this->mImg->getHistory( $oiLimit, $this->mOffset, null, false ) );
		}
		$numRows = count( $this->mHist ); // Total number of query results
		if ( $numRows ) {
			# Index value of top item in the list
			$firstIndex = $this->mIsBackwards ?
				[ $this->mHist[$numRows - 1]->getTimestamp() ] : [ $this->mHist[0]->getTimestamp() ];
			# Discard the extra result row if there is one
			if ( $numRows > $this->mLimit && $numRows > 1 ) {
				if ( $this->mIsBackwards ) {
					# Index value of item past the index
					$this->mPastTheEndIndex = [ $this->mHist[0]->getTimestamp() ];
					# Index value of bottom item in the list
					$lastIndex = [ $this->mHist[1]->getTimestamp() ];
					# Display range
					$this->mRange = [ 1, $numRows - 1 ];
				} else {
					# Index value of item past the index
					$this->mPastTheEndIndex = [ $this->mHist[$numRows - 1]->getTimestamp() ];
					# Index value of bottom item in the list
					$lastIndex = [ $this->mHist[$numRows - 2]->getTimestamp() ];
					# Display range
					$this->mRange = [ 0, $numRows - 2 ];
				}
			} else {
				# Setting indexes to an empty array means that they will be
				# omitted if they would otherwise appear in URLs. It just so
				# happens that this  is the right thing to do in the standard
				# UI, in all the relevant cases.
				$this->mPastTheEndIndex = [];
				# Index value of bottom item in the list
				$lastIndex = $this->mIsBackwards ?
					[ $this->mHist[0]->getTimestamp() ] : [ $this->mHist[$numRows - 1]->getTimestamp() ];
				# Display range
				$this->mRange = [ 0, $numRows - 1 ];
			}
		} else {
			$firstIndex = [];
			$lastIndex = [];
			$this->mPastTheEndIndex = [];
		}
		if ( $this->mIsBackwards ) {
			$this->mIsFirst = ( $numRows < $queryLimit );
			$this->mIsLast = ( $this->mOffset == '' );
			$this->mLastShown = $firstIndex;
			$this->mFirstShown = $lastIndex;
		} else {
			$this->mIsFirst = ( $this->mOffset == '' );
			$this->mIsLast = ( $numRows < $queryLimit );
			$this->mLastShown = $lastIndex;
			$this->mFirstShown = $firstIndex;
		}
		$this->mQueryDone = true;
	}

	/**
	 * @param bool $enable
	 */
	protected function preventClickjacking( $enable = true ) {
		$this->preventClickjacking = $enable;
	}

	/**
	 * @return bool
	 */
	public function getPreventClickjacking() {
		return $this->preventClickjacking;
	}

}
