<?php
declare( strict_types = 1 );

namespace MediaWiki\Extension\Translate\TranslatorSandbox;

use InvalidArgumentException;
use JobQueueGroup;
use MailAddress;
use MediaWiki\Auth\AuthenticationRequest;
use MediaWiki\Auth\AuthenticationResponse;
use MediaWiki\Auth\AuthManager;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Deferred\SiteStatsUpdate;
use MediaWiki\Extension\Translate\HookRunner;
use MediaWiki\Extension\Translate\SystemUsers\TranslateUserManager;
use MediaWiki\Extension\Translate\Utilities\Utilities;
use MediaWiki\MediaWikiServices;
use MediaWiki\Permissions\PermissionManager;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\User\ActorStore;
use MediaWiki\User\Options\UserOptionsManager;
use MediaWiki\User\User;
use MediaWiki\User\UserArray;
use MediaWiki\User\UserFactory;
use MediaWiki\User\UserGroupManager;
use RuntimeException;
use UnexpectedValueException;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\ScopedCallback;

/**
 * Utility class for the sandbox feature of Translate. Do not try this yourself. This code makes a
 * lot of assumptions about what happens to the user account.
 *
 * @author Niklas Laxström
 * @license GPL-2.0-or-later
 */
class TranslateSandbox {
	public const CONSTRUCTOR_OPTIONS = [
		'EmergencyContact',
		'TranslateSandboxPromotedGroup',
	];

	private UserFactory $userFactory;
	private IConnectionProvider $dbProvider;
	private PermissionManager $permissionManager;
	private AuthManager $authManager;
	private UserGroupManager $userGroupManager;
	private ActorStore $actorStore;
	private UserOptionsManager $userOptionsManager;
	private JobQueueGroup $jobQueueGroup;
	private HookRunner $hookRunner;
	private ServiceOptions $options;

	public function __construct(
		UserFactory $userFactory,
		IConnectionProvider $dbProvider,
		PermissionManager $permissionManager,
		AuthManager $authManager,
		UserGroupManager $userGroupManager,
		ActorStore $actorStore,
		UserOptionsManager $userOptionsManager,
		JobQueueGroup $jobQueueGroup,
		HookRunner $hookRunner,
		ServiceOptions $options
	) {
		$this->userFactory = $userFactory;
		$this->dbProvider = $dbProvider;
		$this->permissionManager = $permissionManager;
		$this->authManager = $authManager;
		$this->userGroupManager = $userGroupManager;
		$this->actorStore = $actorStore;
		$this->userOptionsManager = $userOptionsManager;
		$this->jobQueueGroup = $jobQueueGroup;
		$this->hookRunner = $hookRunner;
		$options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
		$this->options = $options;
	}

	/**
	 * Custom exception code used when user creation fails in order to differentiate between
	 * other exceptions that might occur.
	 */
	public const USER_CREATION_FAILURE = 56739;

	/** Adds a new user without doing much validation. */
	public function addUser( string $name, string $email, string $password ): User {
		$user = $this->userFactory->newFromName( $name, UserFactory::RIGOR_CREATABLE );

		if ( !$user ) {
			throw new InvalidArgumentException( 'Invalid user name' );
		}

		$data = [
			'username' => $user->getName(),
			'password' => $password,
			'retype' => $password,
			'email' => $email,
			'realname' => '',
		];

		$creator = TranslateUserManager::getUser();
		$guard = $this->permissionManager->addTemporaryUserRights( $creator, 'createaccount' );

		$reqs = $this->authManager->getAuthenticationRequests( AuthManager::ACTION_CREATE );
		$reqs = AuthenticationRequest::loadRequestsFromSubmission( $reqs, $data );
		$res = $this->authManager->beginAccountCreation( $creator, $reqs, 'null:' );

		ScopedCallback::consume( $guard );

		switch ( $res->status ) {
			case AuthenticationResponse::PASS:
				break;
			case AuthenticationResponse::FAIL:
				// Unless things are misconfigured, this will handle errors such as username taken,
				// invalid user name or too short password. The WebAPI is prechecking these to
				// provide nicer error messages.
				$reason = $res->message->inLanguage( 'en' )->useDatabase( false )->text();
				throw new RuntimeException(
					"Account creation failed: $reason",
					self::USER_CREATION_FAILURE
				);
			default:
				// A provider requested further user input. Abort but clean up first if it was a
				// secondary provider (in which case the user was created).
				if ( $user->getId() ) {
					$this->deleteUser( $user, 'force' );
				}

				throw new RuntimeException(
					'AuthManager does not support such simplified account creation'
				);
		}

		// group-translate-sandboxed group-translate-sandboxed-member
		$this->userGroupManager->addUserToGroup( $user, 'translate-sandboxed' );

		return $user;
	}

	/**
	 * Deletes a sandboxed user without doing much validation.
	 *
	 * @param User $user
	 * @param string $force If set to 'force' will skip the little validation we have.
	 * @throws UserNotSandboxedException
	 */
	public function deleteUser( User $user, string $force = '' ): void {
		$uid = $user->getId();
		$actorId = $user->getActorId();

		if ( $force !== 'force' && !self::isSandboxed( $user ) ) {
			throw new UserNotSandboxedException();
		}

		// Delete from database
		$dbw = $this->dbProvider->getPrimaryDatabase();
		$dbw->newDeleteQueryBuilder()
			->deleteFrom( 'user' )
			->where( [ 'user_id' => $uid ] )
			->caller( __METHOD__ )
			->execute();
		$dbw->newDeleteQueryBuilder()
			->deleteFrom( 'user_groups' )
			->where( [ 'ug_user' => $uid ] )
			->caller( __METHOD__ )
			->execute();
		$dbw->newDeleteQueryBuilder()
			->deleteFrom( 'user_properties' )
			->where( [ 'up_user' => $uid ] )
			->caller( __METHOD__ )
			->execute();

		$this->actorStore->deleteActor( $user, $dbw );

		// Assume no joins are needed for logging or recentchanges
		$dbw->newDeleteQueryBuilder()
			->deleteFrom( 'logging' )
			->where( [ 'log_actor' => $actorId ] )
			->caller( __METHOD__ )
			->execute();
		$dbw->newDeleteQueryBuilder()
			->deleteFrom( 'recentchanges' )
			->where( [ 'rc_actor' => $actorId ] )
			->caller( __METHOD__ )
			->execute();

		// Update the site stats
		$statsUpdate = SiteStatsUpdate::factory( [ 'users' => -1 ] );
		$statsUpdate->doUpdate();

		// If someone tries to access still object still, they will get anon user
		// data.
		$user->clearInstanceCache( 'defaults' );

		// Nobody should access the user by id anymore, but in case they do, purge
		// the cache so they wont get stale data
		$user->invalidateCache();
	}

	/** Get all sandboxed users. */
	public function getUsers(): UserArray {
		$dbr = Utilities::getSafeReadDB();
		$query = User::newQueryBuilder( $dbr );

		$res = $query->join( 'user_groups', null, 'ug_user = user_id' )
			->where( [ 'ug_group' => 'translate-sandboxed' ] )
			->caller( __METHOD__ )
			->fetchResultSet();

		return UserArray::newFromResult( $res );
	}

	/**
	 * Removes the user from the sandbox.
	 * @throws UserNotSandboxedException
	 */
	public function promoteUser( User $user ): void {
		$translateSandboxPromotedGroup = $this->options->get( 'TranslateSandboxPromotedGroup' );

		if ( !self::isSandboxed( $user ) ) {
			throw new UserNotSandboxedException();
		}

		$this->userGroupManager->removeUserFromGroup( $user, 'translate-sandboxed' );
		if ( $translateSandboxPromotedGroup ) {
			$this->userGroupManager->addUserToGroup( $user, $translateSandboxPromotedGroup );
		}

		$this->userOptionsManager->setOption( $user, 'translate-sandbox-reminders', null );
		$this->userOptionsManager->saveOptions( $user );

		$this->hookRunner->onTranslate_TranslatorSandbox_UserPromoted( $user );
	}

	/**
	 * Sends a reminder to the user.
	 * @param User $sender
	 * @param User $target
	 * @param string $type 'reminder' or 'promotion'
	 * @throws UserNotSandboxedException
	 */
	public function sendEmail( User $sender, User $target, string $type ): void {
		$emergencyContact = $this->options->get( 'EmergencyContact' );

		$targetLang = $this->userOptionsManager->getOption( $target, 'language' );

		switch ( $type ) {
			case 'reminder':
				if ( !self::isSandboxed( $target ) ) {
					throw new UserNotSandboxedException();
				}

				$subjectMsg = 'tsb-reminder-title-generic';
				$bodyMsg = 'tsb-reminder-content-generic';
				$targetSpecialPage = 'TranslationStash';

				break;
			case 'promotion':
				$subjectMsg = 'tsb-email-promoted-subject';
				$bodyMsg = 'tsb-email-promoted-body';
				$targetSpecialPage = 'Translate';

				break;
			case 'rejection':
				$subjectMsg = 'tsb-email-rejected-subject';
				$bodyMsg = 'tsb-email-rejected-body';
				$targetSpecialPage = 'TwnMainPage';

				break;
			default:
				throw new UnexpectedValueException( "'$type' is an invalid type of translate sandbox email" );
		}

		$subject = wfMessage( $subjectMsg )->inLanguage( $targetLang )->text();
		$body = wfMessage(
			$bodyMsg,
			$target->getName(),
			SpecialPage::getTitleFor( $targetSpecialPage )->getCanonicalURL(),
			$sender->getName()
		)->inLanguage( $targetLang )->text();

		$params = [
			'user' => $target->getId(),
			'to' => MailAddress::newFromUser( $target ),
			'from' => new MailAddress( $emergencyContact ),
			'replyto' => new MailAddress( $emergencyContact ),
			'subj' => $subject,
			'body' => $body,
			'emailType' => $type,
		];

		$reminders = $this->userOptionsManager->getOption( $target, 'translate-sandbox-reminders' );
		$reminders = $reminders ? explode( '|', $reminders ) : [];
		$reminders[] = wfTimestamp();

		$this->userOptionsManager->setOption( $target, 'translate-sandbox-reminders', implode( '|', $reminders ) );
		$this->userOptionsManager->saveOptions( $target );

		$this->jobQueueGroup->push( TranslateSandboxEmailJob::newJob( $params ) );
	}

	/** Shortcut for checking if given user is in the sandbox. */
	public static function isSandboxed( User $user ): bool {
		$userGroupManager = MediaWikiServices::getInstance()->getUserGroupManager();
		return in_array( 'translate-sandboxed', $userGroupManager->getUserGroups( $user ), true );
	}
}