PageTranslationSpecialPage.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\PageTranslation;
 
use ContentHandler;
use DifferenceEngine;
use ErrorPageError;
use IDBAccessObject;
use InvalidArgumentException;
use JobQueueGroup;
use ManualLogEntry;
use MediaWiki\Cache\LinkBatchFactory;
use MediaWiki\Extension\Translate\MessageGroupProcessing\MessageGroups;
use MediaWiki\Extension\Translate\MessageGroupProcessing\RevTagStore;
use MediaWiki\Extension\Translate\MessageGroupProcessing\TranslatableBundleState;
use MediaWiki\Extension\Translate\MessageProcessing\MessageGroupMetadata;
use MediaWiki\Extension\Translate\Statistics\RebuildMessageGroupStatsJob;
use MediaWiki\Extension\Translate\Synchronization\MessageWebImporter;
use MediaWiki\Extension\Translate\Utilities\LanguagesMultiselectWidget;
use MediaWiki\Extension\Translate\Utilities\Utilities;
use MediaWiki\Extension\TranslationNotifications\SpecialNotifyTranslators;
use MediaWiki\Html\Html;
use MediaWiki\Languages\LanguageFactory;
use MediaWiki\Page\PageRecord;
use MediaWiki\Permissions\PermissionManager;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\Title\Title;
use OOUI\ButtonInputWidget;
use OOUI\CheckboxInputWidget;
use OOUI\FieldLayout;
use OOUI\FieldsetLayout;
use OOUI\HtmlSnippet;
use OOUI\RadioInputWidget;
use OOUI\TextInputWidget;
use PermissionsError;
use UnexpectedValueException;
use User;
use UserBlockedError;
use WebRequest;
use Wikimedia\Rdbms\IResultWrapper;
use Xml;
use function count;
use function wfEscapeWikiText;
 
class PageTranslationSpecialPage extends SpecialPage {
    private const DISPLAY_STATUS_MAPPING = [
        TranslatablePageStatus::PROPOSED => 'proposed',
        TranslatablePageStatus::ACTIVE => 'active',
        TranslatablePageStatus::OUTDATED => 'outdated',
        TranslatablePageStatus::BROKEN => 'broken'
    ];
    private LanguageFactory $languageFactory;
    private LinkBatchFactory $linkBatchFactory;
    private JobQueueGroup $jobQueueGroup;
    private PermissionManager $permissionManager;
    private TranslatablePageMarker $translatablePageMarker;
    private TranslatablePageParser $translatablePageParser;
    private MessageGroupMetadata $messageGroupMetadata;
    private TranslatablePageView $translatablePageView;
    private TranslatablePageStateStore $translatablePageStateStore;
 
    public function __construct(
        LanguageFactory $languageFactory,
        LinkBatchFactory $linkBatchFactory,
        JobQueueGroup $jobQueueGroup,
        PermissionManager $permissionManager,
        TranslatablePageMarker $translatablePageMarker,
        TranslatablePageParser $translatablePageParser,
        MessageGroupMetadata $messageGroupMetadata,
        TranslatablePageView $translatablePageView,
        TranslatablePageStateStore $translatablePageStateStore
    ) {
        parent::__construct( 'PageTranslation' );
        $this->languageFactory = $languageFactory;
        $this->linkBatchFactory = $linkBatchFactory;
        $this->jobQueueGroup = $jobQueueGroup;
        $this->permissionManager = $permissionManager;
        $this->translatablePageMarker = $translatablePageMarker;
        $this->translatablePageParser = $translatablePageParser;
        $this->messageGroupMetadata = $messageGroupMetadata;
        $this->translatablePageView = $translatablePageView;
        $this->translatablePageStateStore = $translatablePageStateStore;
    }
 
    public function doesWrites(): bool {
        return true;
    }
 
    protected function getGroupName(): string {
        return 'translation';
    }
 
    public function execute( $parameters ) {
        $this->setHeaders();
 
        $user = $this->getUser();
        $request = $this->getRequest();
 
        $target = $request->getText( 'target', $parameters ?? '' );
        $revision = $request->getIntOrNull( 'revision' );
        $action = $request->getVal( 'do' );
        $out = $this->getOutput();
        $out->addModules( 'ext.translate.special.pagetranslation' );
        $out->addModuleStyles( 'ext.translate.specialpages.styles' );
        $out->addHelpLink( 'Help:Extension:Translate/Page_translation_example' );
        $out->enableOOUI();
 
        if ( $target === '' ) {
            $this->listPages();
 
            return;
        }
 
        $title = Title::newFromText( $target );
        if ( !$title ) {
            $out->wrapWikiMsg( Html::errorBox( '$1' ), [ 'tpt-badtitle', $target ] );
            $out->addWikiMsg( 'tpt-list-pages-in-translations' );
 
            return;
        } elseif ( !$title->exists() ) {
            $out->wrapWikiMsg(
                Html::errorBox( '$1' ),
                [ 'tpt-nosuchpage', $title->getPrefixedText() ]
            );
            $out->addWikiMsg( 'tpt-list-pages-in-translations' );
 
            return;
        }
 
        if ( $action === 'settings' && !$this->translatablePageView->isTranslationBannerNamespaceConfigured() ) {
            $this->showTranslationStateRestricted();
            return;
        }
 
        $block = $this->getBlock( $request, $user, $title );
        if ( $action === 'settings' && !$request->wasPosted() ) {
            $this->showTranslationSettings( $title, $block );
            return;
        }
 
        if ( $block ) {
            throw $block;
        }
 
        // Check token for all POST actions here
        $csrfTokenSet = $this->getContext()->getCsrfTokenSet();
        if ( $request->wasPosted() && !$csrfTokenSet->matchTokenField( 'token' ) ) {
            throw new PermissionsError( 'pagetranslation' );
        }
 
        if ( $action === 'settings' && $request->wasPosted() ) {
            $this->handleTranslationState( $title, $request->getRawVal( 'translatable-page-state' ) );
            return;
        }
 
        // Anything other than listing the pages or manipulating settings needs permissions
        if ( !$user->isAllowed( 'pagetranslation' ) ) {
            throw new PermissionsError( 'pagetranslation' );
        }
 
        if ( $action === 'mark' ) {
            // Has separate form
            $this->onActionMark( $title, $revision );
 
            return;
        }
 
        // On GET requests, show form which has token
        if ( !$request->wasPosted() ) {
            if ( $action === 'unlink' ) {
                $this->showUnlinkConfirmation( $title );
            } else {
                $params = [
                    'do' => $action,
                    'target' => $title->getPrefixedText(),
                    'revision' => $revision,
                ];
                $this->showGenericConfirmation( $params );
            }
 
            return;
        }
 
        if ( $action === 'discourage' || $action === 'encourage' ) {
            $id = TranslatablePage::getMessageGroupIdFromTitle( $title );
            $current = MessageGroups::getPriority( $id );
 
            if ( $action === 'encourage' ) {
                $new = '';
            } else {
                $new = 'discouraged';
            }
 
            if ( $new !== $current ) {
                MessageGroups::setPriority( $id, $new );
                $entry = new ManualLogEntry( 'pagetranslation', $action );
                $entry->setPerformer( $user );
                $entry->setTarget( $title );
                $logId = $entry->insert();
                $entry->publish( $logId );
            }
 
            // Defer stats purging of parent aggregate groups. Shared groups can contain other
            // groups as well, which we do not need to update. We could filter non-aggregate
            // groups out, or use MessageGroups::getParentGroups, though it has an inconvenient
            // return value format for this use case.
            $group = MessageGroups::getGroup( $id );
            $sharedGroupIds = MessageGroups::getSharedGroups( $group );
            if ( $sharedGroupIds !== [] ) {
                $job = RebuildMessageGroupStatsJob::newRefreshGroupsJob( $sharedGroupIds );
                $this->jobQueueGroup->push( $job );
            }
 
            // Show updated page with a notice
            $this->listPages();
 
            return;
        }
 
        if ( $action === 'unlink' || $action === 'unmark' ) {
            try {
                $this->translatablePageMarker->unmarkPage(
                    TranslatablePage::newFromTitle( $title ),
                    $user,
                    $action === 'unlink'
                );
 
                $out->wrapWikiMsg(
                    Html::successBox( '$1' ),
                    [ 'tpt-unmarked', $title->getPrefixedText() ]
                );
            } catch ( TranslatablePageMarkException $e ) {
                $out->wrapWikiMsg(
                    Html::errorBox( '$1' ),
                    $e->getMessageObject()
                );
            }
 
            $out->addWikiMsg( 'tpt-list-pages-in-translations' );
        }
    }
 
    protected function onActionMark( Title $title, ?int $revision ): void {
        $request = $this->getRequest();
        $out = $this->getOutput();
        $translateTitle = $request->getCheck( 'translatetitle' );
 
        try {
            $operation = $this->translatablePageMarker->getMarkOperation(
                $title->toPageRecord(
                    $request->wasPosted() ? IDBAccessObject::READ_LATEST : IDBAccessObject::READ_NORMAL
                ),
                $revision,
                // If the request was not posted, validate all the units so that initially we display all the errors
                // and then the user can choose whether they want to translate the title
                !$request->wasPosted() || $translateTitle
            );
        } catch ( TranslatablePageMarkException $e ) {
            $out->addHTML( Html::errorBox( $this->msg( $e->getMessageObject() )->parse() ) );
            $out->addWikiMsg( 'tpt-list-pages-in-translations' );
            return;
        }
 
        $unitNameValidationResult = $operation->getUnitValidationStatus();
        // Non-fatal error which prevents saving
        if ( $unitNameValidationResult->isOK() && $request->wasPosted() ) {
            // Fetch priority language related information
            [ $priorityLanguages, $forcePriorityLanguage, $priorityLanguageReason ] =
                $this->getPriorityLanguage( $this->getRequest() );
 
            $noFuzzyUnits = array_filter(
                preg_replace(
                    '/^tpt-sect-(.*)-action-nofuzzy$|.*/',
                    '$1',
                    array_keys( $request->getValues() )
                ),
                'strlen'
            );
 
            // https://www.php.net/manual/en/language.variables.external.php says:
            // "Dots and spaces in variable names are converted to underscores.
            // For example <input name="a b" /> becomes $_REQUEST["a_b"]."
            // Therefore, we need to convert underscores back to spaces where they were used in section
            // markers.
            $noFuzzyUnits = str_replace( '_', ' ', $noFuzzyUnits );
 
            $translatablePageSettings = new TranslatablePageSettings(
                $priorityLanguages,
                $forcePriorityLanguage,
                $priorityLanguageReason,
                $noFuzzyUnits,
                $translateTitle,
                $request->getCheck( 'use-latest-syntax' ),
                $request->getCheck( 'transclusion' )
            );
 
            try {
                $unitCount = $this->translatablePageMarker->markForTranslation(
                    $operation,
                    $translatablePageSettings,
                    $this->getUser()
                );
                $this->showSuccess( $operation->getPage(), $operation->isFirstMark(), $unitCount );
            } catch ( TranslatablePageMarkException $e ) {
                $out->wrapWikiMsg(
                    Html::errorBox( '$1' ),
                    $e->getMessageObject()
                );
            }
        } else {
            if ( !$unitNameValidationResult->isOK() ) {
                $out->addHTML(
                    Html::errorBox(
                        $unitNameValidationResult->getHTML( false, false, $this->getLanguage() )
                    )
                );
            }
 
            $this->showPage( $operation );
        }
    }
 
    private function showSuccess( TranslatablePage $page, bool $firstMark, int $unitCount ): void {
        $titleText = $page->getTitle()->getPrefixedText();
        $num = $this->getLanguage()->formatNum( $unitCount );
        $link = SpecialPage::getTitleFor( 'Translate' )->getFullURL( [
            'group' => $page->getMessageGroupId(),
            'action' => 'page',
            'filter' => '',
        ] );
 
        $this->getOutput()->wrapWikiMsg(
            Html::successBox( '$1' ),
            [ 'tpt-saveok', $titleText, $num, $link ]
        );
 
        // If the page is being marked for translation for the first time
        // add a link to Special:PageMigration.
        if ( $firstMark ) {
            $this->getOutput()->addWikiMsg( 'tpt-saveok-first' );
        }
 
        // If TranslationNotifications is installed, and the user can notify
        // translators, add a convenience link.
        if ( method_exists( SpecialNotifyTranslators::class, 'execute' ) &&
            $this->getUser()->isAllowed( SpecialNotifyTranslators::$right )
        ) {
            $link = SpecialPage::getTitleFor( 'NotifyTranslators' )->getFullURL(
                [ 'tpage' => $page->getTitle()->getArticleID() ]
            );
            $this->getOutput()->addWikiMsg( 'tpt-offer-notify', $link );
        }
 
        $this->getOutput()->addWikiMsg( 'tpt-list-pages-in-translations' );
    }
 
    private function showGenericConfirmation( array $params ): void {
        $formParams = [
            'method' => 'post',
            'action' => $this->getPageTitle()->getLocalURL(),
        ];
 
        $params['title'] = $this->getPageTitle()->getPrefixedText();
        $params['token'] = $this->getContext()->getCsrfTokenSet()->getToken();
 
        $hidden = '';
        foreach ( $params as $key => $value ) {
            $hidden .= Html::hidden( $key, $value );
        }
 
        $this->getOutput()->addHTML(
            Html::openElement( 'form', $formParams ) .
            $hidden .
            $this->msg( 'tpt-generic-confirm' )->parseAsBlock() .
            Xml::submitButton(
                $this->msg( 'tpt-generic-button' )->text(),
                [ 'class' => 'mw-ui-button mw-ui-progressive' ]
            ) .
            Html::closeElement( 'form' )
        );
    }
 
    private function showUnlinkConfirmation( Title $target ): void {
        $formParams = [
            'method' => 'post',
            'action' => $this->getPageTitle()->getLocalURL(),
        ];
 
        $this->getOutput()->addHTML(
            Html::openElement( 'form', $formParams ) .
            Html::hidden( 'do', 'unlink' ) .
            Html::hidden( 'title', $this->getPageTitle()->getPrefixedText() ) .
            Html::hidden( 'target', $target->getPrefixedText() ) .
            Html::hidden( 'token', $this->getContext()->getCsrfTokenSet()->getToken() ) .
            $this->msg( 'tpt-unlink-confirm', $target->getPrefixedText() )->parseAsBlock() .
            Xml::submitButton(
                $this->msg( 'tpt-unlink-button' )->text(),
                [ 'class' => 'mw-ui-button mw-ui-destructive' ]
            ) .
            Html::closeElement( 'form' )
        );
    }
 
    public static function loadPagesFromDB(): IResultWrapper {
        $dbr = Utilities::getSafeReadDB();
        return $dbr->newSelectQueryBuilder()
            ->select( [
                'page_id',
                'page_namespace',
                'page_title',
                'page_latest',
                'rt_revision' => 'MAX(rt_revision)',
                'rt_type'
            ] )
            ->from( 'page' )
            ->join( 'revtag', null, 'page_id=rt_page' )
            ->where( [
                'rt_type' => [ RevTagStore::TP_MARK_TAG, RevTagStore::TP_READY_TAG ],
            ] )
            ->orderBy( [ 'page_namespace', 'page_title' ] )
            ->groupBy( [ 'page_id', 'page_namespace', 'page_title', 'page_latest', 'rt_type' ] )
            ->caller( __METHOD__ )
            ->fetchResultSet();
    }
 
    public static function buildPageArray( IResultWrapper $res ): array {
        $pages = [];
        foreach ( $res as $r ) {
            // We have multiple rows for same page, because of different tags
            if ( !isset( $pages[$r->page_id] ) ) {
                $pages[$r->page_id] = [];
                $title = Title::newFromRow( $r );
                $pages[$r->page_id]['title'] = $title;
                $pages[$r->page_id]['latest'] = (int)$title->getLatestRevID();
            }
 
            $tag = $r->rt_type;
            $pages[$r->page_id][$tag] = (int)$r->rt_revision;
        }
 
        return $pages;
    }
 
    private function classifyPages( array $pages ): array {
        $out = [
            // The ideal state for pages: marked and up to date
            'active' => [],
            'proposed' => [],
            'outdated' => [],
            'broken' => [],
        ];
 
        if ( $pages === [] ) {
            return $out;
        }
 
        // Preload stuff for performance
        $messageGroupIdsForPreload = [];
        foreach ( $pages as $i => $page ) {
            $id = TranslatablePage::getMessageGroupIdFromTitle( $page['title'] );
            $messageGroupIdsForPreload[] = $id;
            $pages[$i]['groupid'] = $id;
        }
        // Performance optimization: load only data we need to classify the pages
        $metadata = $this->messageGroupMetadata->loadBasicMetadataForTranslatablePages(
            $messageGroupIdsForPreload,
            [ 'transclusion', 'version' ]
        );
 
        foreach ( $pages as $page ) {
            $groupId = $page['groupid'];
            $group = MessageGroups::getGroup( $groupId );
            $page['discouraged'] = MessageGroups::getPriority( $group ) === 'discouraged';
            $page['version'] = $metadata[$groupId]['version'] ?? TranslatablePageMarker::DEFAULT_SYNTAX_VERSION;
            $page['transclusion'] = $metadata[$groupId]['transclusion'] ?? false;
 
            // TODO: Eventually we should query the status directly from the TranslatableBundleStore
            $tpStatus = TranslatablePage::determineStatus(
                $page[RevTagStore::TP_READY_TAG] ?? null,
                $page[RevTagStore::TP_MARK_TAG] ?? null,
                $page['latest']
            );
 
            if ( !$tpStatus ) {
                // Ignore pages for which status could not be determined.
                continue;
            }
 
            $out[self::DISPLAY_STATUS_MAPPING[$tpStatus->getId()]][] = $page;
        }
 
        return $out;
    }
 
    public function listPages(): void {
        $out = $this->getOutput();
 
        $res = self::loadPagesFromDB();
        $allPages = self::buildPageArray( $res );
 
        $pagesWithProposedState = [];
        if ( $this->translatablePageView->isTranslationBannerNamespaceConfigured() ) {
            $pagesWithProposedState = $this->translatablePageStateStore->getRequested();
        }
 
        if ( !count( $allPages ) && !count( $pagesWithProposedState ) ) {
            $out->addWikiMsg( 'tpt-list-nopages' );
 
            return;
        }
 
        $lb = $this->linkBatchFactory->newLinkBatch();
        $lb->setCaller( __METHOD__ );
        foreach ( $allPages as $page ) {
            $lb->addObj( $page['title'] );
        }
 
        foreach ( $pagesWithProposedState as $title ) {
            $lb->addObj( $title );
        }
        $lb->execute();
 
        $types = $this->classifyPages( $allPages );
 
        $pages = $types['proposed'];
        if ( $pages || $pagesWithProposedState ) {
            $out->wrapWikiMsg( '== $1 ==', 'tpt-new-pages-title' );
            if ( $pages ) {
                $out->addWikiMsg( 'tpt-new-pages', count( $pages ) );
                $out->addHTML( $this->getPageList( $pages, 'proposed' ) );
            }
 
            if ( $pagesWithProposedState ) {
                $out->addWikiMsg( 'tpt-proposed-state-pages', count( $pagesWithProposedState ) );
                $out->addHTML( $this->displayPagesWithProposedState( $pagesWithProposedState ) );
            }
        }
 
        $pages = $types['broken'];
        if ( $pages ) {
            $out->wrapWikiMsg( '== $1 ==', 'tpt-other-pages-title' );
            $out->addWikiMsg( 'tpt-other-pages', count( $pages ) );
            $out->addHTML( $this->getPageList( $pages, 'broken' ) );
        }
 
        $pages = $types['outdated'];
        if ( $pages ) {
            $out->wrapWikiMsg( '== $1 ==', 'tpt-outdated-pages-title' );
            $out->addWikiMsg( 'tpt-outdated-pages', count( $pages ) );
            $out->addHTML( $this->getPageList( $pages, 'outdated' ) );
        }
 
        $pages = $types['active'];
        if ( $pages ) {
            $out->wrapWikiMsg( '== $1 ==', 'tpt-old-pages-title' );
            $out->addWikiMsg( 'tpt-old-pages', count( $pages ) );
            $out->addHTML( $this->getPageList( $pages, 'active' ) );
        }
    }
 
    private function actionLinks( array $page, string $type ): string {
        // Performance optimization to avoid calling $this->msg in a loop
        static $messageCache = null;
        if ( $messageCache === null ) {
            $messageCache = [
                'mark' => $this->msg( 'tpt-rev-mark' )->text(),
                'mark-tooltip' => $this->msg( 'tpt-rev-mark-tooltip' )->text(),
                'encourage' => $this->msg( 'tpt-rev-encourage' )->text(),
                'encourage-tooltip' => $this->msg( 'tpt-rev-encourage-tooltip' )->text(),
                'discourage' => $this->msg( 'tpt-rev-discourage' )->text(),
                'discourage-tooltip' => $this->msg( 'tpt-rev-discourage-tooltip' )->text(),
                'unmark' => $this->msg( 'tpt-rev-unmark' )->text(),
                'unmark-tooltip' => $this->msg( 'tpt-rev-unmark-tooltip' )->text(),
                'pipe-separator' => $this->msg( 'pipe-separator' )->escaped(),
            ];
        }
 
        $actions = [];
        $title = $page['title'];
        $user = $this->getUser();
 
        // Class to allow one-click POSTs
        $js = [ 'class' => 'mw-translate-jspost' ];
 
        if ( $user->isAllowed( 'pagetranslation' ) ) {
            // Enable re-marking of all pages to allow changing of priority languages
            // or migration to the new syntax version
            if ( $type !== 'broken' ) {
                $actions[] = $this->getLinkRenderer()->makeKnownLink(
                    $this->getPageTitle(),
                    $messageCache['mark'],
                    [ 'title' => $messageCache['mark-tooltip'] ],
                    [
                        'do' => 'mark',
                        'target' => $title->getPrefixedText(),
                        'revision' => $title->getLatestRevID(),
                    ]
                );
            }
 
            if ( $type !== 'proposed' ) {
                if ( $page['discouraged'] ) {
                    $actions[] = $this->getLinkRenderer()->makeKnownLink(
                        $this->getPageTitle(),
                        $messageCache['encourage'],
                        [ 'title' => $messageCache['encourage-tooltip'] ] + $js,
                        [
                            'do' => 'encourage',
                            'target' => $title->getPrefixedText(),
                            'revision' => -1,
                        ]
                    );
                } else {
                    $actions[] = $this->getLinkRenderer()->makeKnownLink(
                        $this->getPageTitle(),
                        $messageCache['discourage'],
                        [ 'title' => $messageCache['discourage-tooltip'] ] + $js,
                        [
                            'do' => 'discourage',
                            'target' => $title->getPrefixedText(),
                            'revision' => -1,
                        ]
                    );
                }
 
                $actions[] = $this->getLinkRenderer()->makeKnownLink(
                    $this->getPageTitle(),
                    $messageCache['unmark'],
                    [ 'title' => $messageCache['unmark-tooltip'] ],
                    [
                        'do' => $type === 'broken' ? 'unmark' : 'unlink',
                        'target' => $title->getPrefixedText(),
                        'revision' => -1,
                    ]
                );
            }
        }
 
        if ( !$actions ) {
            return '';
        }
 
        return '<div>' . implode( $messageCache['pipe-separator'], $actions ) . '</div>';
    }
 
    private function showPage( TranslatablePageMarkOperation $operation ): void {
        $page = $operation->getPage();
        $out = $this->getOutput();
        $out->addBacklinkSubtitle( $page->getTitle() );
        $out->addWikiMsg( 'tpt-showpage-intro' );
 
        $this->addPageForm(
            $page->getTitle(),
            'mw-tpt-sp-markform',
            'mark',
            $page->getRevision()
        );
 
        $out->wrapWikiMsg( '==$1==', 'tpt-sections-oldnew' );
 
        $diffOld = $this->msg( 'tpt-diff-old' )->escaped();
        $diffNew = $this->msg( 'tpt-diff-new' )->escaped();
        $hasChanges = false;
 
        // Check whether page title was previously marked for translation.
        // If the page is marked for translation the first time, default to checked,
        // unless the page is a template. T305240
        $defaultChecked = (
            $operation->isFirstMark() &&
            !$page->getTitle()->inNamespace( NS_TEMPLATE )
        ) || $page->hasPageDisplayTitle();
 
        $sourceLanguage = $this->languageFactory->getLanguage( $page->getSourceLanguageCode() );
 
        foreach ( $operation->getUnits() as $s ) {
            if ( $s->id === TranslatablePage::DISPLAY_TITLE_UNIT_ID ) {
                // Set section type as new if title previously unchecked
                $s->type = $defaultChecked ? $s->type : 'new';
 
                // Checkbox for page title optional translation
                $checkBox = new FieldLayout(
                    new CheckboxInputWidget( [
                        'name' => 'translatetitle',
                        'selected' => $defaultChecked,
                    ] ),
                    [
                        'label' => $this->msg( 'tpt-translate-title' )->text(),
                        'align' => 'inline',
                        'classes' => [ 'mw-tpt-m-vertical' ]
                    ]
                );
                $out->addHTML( $checkBox->toString() );
            }
 
            if ( $s->type === 'new' ) {
                $hasChanges = true;
                $name = $this->msg( 'tpt-section-new', $s->id )->escaped();
            } else {
                $name = $this->msg( 'tpt-section', $s->id )->escaped();
            }
 
            if ( $s->type === 'changed' ) {
                $hasChanges = true;
                $diff = new DifferenceEngine();
                $diff->setTextLanguage( $sourceLanguage );
                $diff->setReducedLineNumbers();
 
                $oldContent = ContentHandler::makeContent( $s->getOldText(), $diff->getTitle() );
                $newContent = ContentHandler::makeContent( $s->getText(), $diff->getTitle() );
 
                $diff->setContent( $oldContent, $newContent );
 
                $text = $diff->getDiff( $diffOld, $diffNew );
                $diffOld = $diffNew = null;
                $diff->showDiffStyle();
 
                $id = "tpt-sect-{$s->id}-action-nofuzzy";
                $checkLabel = new FieldLayout(
                    new CheckboxInputWidget( [
                        'name' => $id,
                        'selected' => $s->onlyTvarsChanged()
                    ] ),
                    [
                        'label' => $this->msg( 'tpt-action-nofuzzy' )->text(),
                        'align' => 'inline',
                        'classes' => [ 'mw-tpt-m-vertical' ]
                    ]
                );
                $text = $checkLabel->toString() . $text;
            } else {
                $text = Utilities::convertWhiteSpaceToHTML( $s->getText() );
            }
 
            # For changed text, the language is set by $diff->setTextLanguage()
            $lang = $s->type === 'changed' ? null : $sourceLanguage;
            $out->addHTML( MessageWebImporter::makeSectionElement(
                $name,
                $s->type,
                $text,
                $lang
            ) );
 
            foreach ( $s->getIssues() as $issue ) {
                $severity = $issue->getSeverity();
                if ( $severity === TranslationUnitIssue::WARNING ) {
                    $box = Html::warningBox( $this->msg( $issue )->escaped() );
                } elseif ( $severity === TranslationUnitIssue::ERROR ) {
                    $box = Html::errorBox( $this->msg( $issue )->escaped() );
                } else {
                    throw new UnexpectedValueException(
                        "Unknown severity: $severity for key: {$issue->getKey()}"
                    );
                }
 
                $out->addHTML( $box );
            }
        }
 
        if ( $operation->getDeletedUnits() ) {
            $hasChanges = true;
            $out->wrapWikiMsg( '==$1==', 'tpt-sections-deleted' );
 
            foreach ( $operation->getDeletedUnits() as $s ) {
                $name = $this->msg( 'tpt-section-deleted', $s->id )->escaped();
                $text = Utilities::convertWhiteSpaceToHTML( $s->getText() );
                $out->addHTML( MessageWebImporter::makeSectionElement(
                    $name,
                    'deleted',
                    $text,
                    $sourceLanguage
                ) );
            }
        }
 
        // Display template changes if applicable
        $markedTag = $page->getMarkedTag();
        if ( $markedTag !== null ) {
            $hasChanges = true;
            $newTemplate = $operation->getParserOutput()->sourcePageTemplateForDiffs();
            $oldPage = TranslatablePage::newFromRevision(
                $page->getTitle(),
                $markedTag
            );
            $oldTemplate = $this->translatablePageParser
                ->parse( $oldPage->getText() )
                ->sourcePageTemplateForDiffs();
 
            if ( $oldTemplate !== $newTemplate ) {
                $out->wrapWikiMsg( '==$1==', 'tpt-sections-template' );
 
                $diff = new DifferenceEngine();
                $diff->setTextLanguage( $sourceLanguage );
 
                $oldContent = ContentHandler::makeContent( $oldTemplate, $diff->getTitle() );
                $newContent = ContentHandler::makeContent( $newTemplate, $diff->getTitle() );
 
                $diff->setContent( $oldContent, $newContent );
 
                $text = $diff->getDiff(
                    $this->msg( 'tpt-diff-old' )->escaped(),
                    $this->msg( 'tpt-diff-new' )->escaped()
                );
                $diff->showDiffStyle();
                $diff->setReducedLineNumbers();
 
                $out->addHTML( Xml::tags( 'div', [], $text ) );
            }
        }
 
        if ( !$hasChanges ) {
            $out->wrapWikiMsg( Html::successBox( '$1' ), 'tpt-mark-nochanges' );
        }
 
        $this->priorityLanguagesForm( $page );
 
        // If an existing page does not have the supportsTransclusion flag, keep the checkbox unchecked,
        // If the page is being marked for translation for the first time, the checkbox can be checked
        $this->templateTransclusionForm( $page->supportsTransclusion() ?? $operation->isFirstMark() );
 
        $version = $this->messageGroupMetadata->getWithDefaultValue(
            $page->getMessageGroupId(), 'version', TranslatablePageMarker::DEFAULT_SYNTAX_VERSION
        );
        $this->syntaxVersionForm( $version, $operation->isFirstMark() );
 
        $submitButton = new FieldLayout(
            new ButtonInputWidget( [
                'label' => $this->msg( 'tpt-submit' )->text(),
                'type' => 'submit',
                'flags' => [ 'primary', 'progressive' ],
            ] ),
            [
                'label' => null,
                'align' => 'top',
            ]
        );
 
        $out->addHTML( $submitButton->toString() );
        $out->addHTML( '</form>' );
    }
 
    private function priorityLanguagesForm( TranslatablePage $page ): void {
        $groupId = $page->getMessageGroupId();
        $interfaceLanguage = $this->getLanguage()->getCode();
        $storedLanguages = (string)$this->messageGroupMetadata->get( $groupId, 'prioritylangs' );
        $default = $storedLanguages !== '' ? explode( ',', $storedLanguages ) : [];
 
        $priorityReason = $this->messageGroupMetadata->get( $groupId, 'priorityreason' );
        $priorityReason = $priorityReason !== false ? $priorityReason : '';
 
        $form = new FieldsetLayout( [
            'items' => [
                new FieldLayout(
                    new LanguagesMultiselectWidget( [
                        'infusable' => true,
                        'name' => 'prioritylangs',
                        'id' => 'mw-translate-SpecialPageTranslation-prioritylangs',
                        'languages' => Utilities::getLanguageNames( $interfaceLanguage ),
                        'default' => $default,
                    ] ),
                    [
                        'label' => $this->msg( 'tpt-select-prioritylangs' )->text(),
                        'align' => 'top',
                    ]
                ),
                new FieldLayout(
                    new CheckboxInputWidget( [
                        'name' => 'forcelimit',
                        'selected' => $this->messageGroupMetadata->get( $groupId, 'priorityforce' ) === 'on',
                    ] ),
                    [
                        'label' => $this->msg( 'tpt-select-prioritylangs-force' )->text(),
                        'align' => 'inline',
                        'help' => new HtmlSnippet( $this->msg( 'tpt-select-no-prioritylangs-force' )->parse() ),
                    ]
                ),
                new FieldLayout(
                    new TextInputWidget( [
                        'name' => 'priorityreason',
                        'value' => $priorityReason
                    ] ),
                    [
                        'label' => $this->msg( 'tpt-select-prioritylangs-reason' )->text(),
                        'align' => 'top',
                    ]
                ),
 
            ],
        ] );
 
        $this->getOutput()->wrapWikiMsg( '==$1==', 'tpt-sections-prioritylangs' );
        $this->getOutput()->addHTML( $form->toString() );
    }
 
    private function syntaxVersionForm( string $version, bool $firstMark ): void {
        $out = $this->getOutput();
 
        if ( $version === TranslatablePageMarker::LATEST_SYNTAX_VERSION || $firstMark ) {
            return;
        }
 
        $out->wrapWikiMsg( '==$1==', 'tpt-sections-syntaxversion' );
        $out->addWikiMsg(
            'tpt-syntaxversion-text',
            '<code>' . wfEscapeWikiText( '<span lang="en" dir="ltr">...</span>' ) . '</code>',
            '<code>' . wfEscapeWikiText( '<translate nowrap>...</translate>' ) . '</code>'
        );
 
        $checkBox = new FieldLayout(
            new CheckboxInputWidget( [
                'name' => 'use-latest-syntax'
            ] ),
            [
                'label' => $out->msg( 'tpt-syntaxversion-label' )->text(),
                'align' => 'inline',
            ]
        );
 
        $out->addHTML( $checkBox->toString() );
    }
 
    private function templateTransclusionForm( bool $supportsTransclusion ): void {
        $out = $this->getOutput();
        $out->wrapWikiMsg( '==$1==', 'tpt-transclusion' );
 
        $checkBox = new FieldLayout(
            new CheckboxInputWidget( [
                'name' => 'transclusion',
                'selected' => $supportsTransclusion
            ] ),
            [
                'label' => $out->msg( 'tpt-transclusion-label' )->text(),
                'align' => 'inline',
            ]
        );
 
        $out->addHTML( $checkBox->toString() );
    }
 
    private function getPriorityLanguage( WebRequest $request ): array {
        // Get the priority languages from the request
        // We've to do some extra work here because if JS is disabled, we will be getting
        // the values split by newline.
        $priorityLanguages = rtrim( trim( $request->getVal( 'prioritylangs', '' ) ), ',' );
        $priorityLanguages = str_replace( "\n", ',', $priorityLanguages );
        $priorityLanguages = array_map( 'trim', explode( ',', $priorityLanguages ) );
        $priorityLanguages = array_unique( array_filter( $priorityLanguages ) );
 
        $forcePriorityLanguage = $request->getCheck( 'forcelimit' );
        $priorityLanguageReason = trim( $request->getText( 'priorityreason' ) );
 
        return [ $priorityLanguages, $forcePriorityLanguage, $priorityLanguageReason ];
    }
 
    private function getPageList( array $pages, string $type ): string {
        $items = [];
        $tagsTextCache = [];
 
        $tagDiscouraged = $this->msg( 'tpt-tag-discouraged' )->escaped();
        $tagOldSyntax = $this->msg( 'tpt-tag-oldsyntax' )->escaped();
        $tagNoTransclusionSupport = $this->msg( 'tpt-tag-no-transclusion-support' )->escaped();
 
        foreach ( $pages as $page ) {
            $link = $this->getLinkRenderer()->makeKnownLink( $page['title'] );
            $acts = $this->actionLinks( $page, $type );
            $tags = [];
            if ( $page['discouraged'] ) {
                $tags[] = $tagDiscouraged;
            }
            if ( $type !== 'proposed' ) {
                if ( $page['version'] !== TranslatablePageMarker::LATEST_SYNTAX_VERSION ) {
                    $tags[] = $tagOldSyntax;
                }
 
                if ( $page['transclusion'] !== '1' ) {
                    $tags[] = $tagNoTransclusionSupport;
                }
            }
 
            $tagList = '';
            if ( $tags ) {
                // Performance optimization to avoid calling $this->msg in a loop
                $tagsKey = implode( '', $tags );
                $tagsTextCache[$tagsKey] ??= $this->msg( 'parentheses' )
                    ->rawParams( $this->getLanguage()->pipeList( $tags ) )
                    ->escaped();
 
                $tagList = Html::rawElement(
                    'span',
                    [ 'class' => 'mw-tpt-actions' ],
                    $tagsTextCache[$tagsKey]
                );
            }
 
            $items[] = "<li class='mw-tpt-pagelist-item'>$link $tagList $acts</li>";
        }
 
        return '<ol>' . implode( '', $items ) . '</ol>';
    }
 
    private function displayPagesWithProposedState( array $pagesWithProposedState ): string {
        $items = [];
        $preparePageAction = $this->msg( 'tpt-prepare-page' )->text();
        $preparePageTooltip = $this->msg( 'tpt-prepare-page-tooltip' )->text();
        $linkRenderer = $this->getLinkRenderer();
        foreach ( $pagesWithProposedState as $pageRecord ) {
            $link = $linkRenderer->makeKnownLink( $pageRecord );
            $action = $linkRenderer->makeKnownLink(
                SpecialPage::getTitleFor( 'PagePreparation' ),
                $preparePageAction,
                [ 'title' => $preparePageTooltip ],
                [ 'page' => ( Title::newFromPageReference( $pageRecord ) )->getPrefixedText() ]
            );
            $items[] = "<li class='mw-tpt-pagelist-item'>$link <div>$action</div></li>";
        }
        return '<ol>' . implode( '', $items ) . '</ol>';
    }
 
    private function showTranslationSettings( Title $target, ?ErrorPageError $block ): void {
        $out = $this->getOutput();
        $out->setPageTitle( $this->msg( 'tpt-translation-settings-page-title' )->text() );
        $out->addBacklinkSubtitle( $target );
 
        $currentState = $this->translatablePageStateStore->get( $target );
 
        if ( !$this->translatablePageView->canManageTranslationSettings( $target, $this->getUser() ) ) {
            $out->wrapWikiMsg( Html::errorBox( '$1' ), 'tpt-translation-settings-restricted' );
            $out->addWikiMsg( 'tpt-list-pages-in-translations' );
            return;
        }
 
        if ( $block ) {
            $out->wrapWikiMsg( Html::errorBox( '$1' ), $block->getMessageObject() );
        }
 
        if ( $currentState ) {
            $this->displayStateInfoMessage( $target, $currentState );
        }
 
        $this->addPageForm( $target, 'mw-tpt-sp-settings', 'settings', null );
        $out->addHTML(
            Html::rawElement(
                'p',
                [ 'class' => 'mw-tpt-vm' ],
                Html::element( 'strong', [], $this->msg( 'tpt-translation-settings-subtitle' ) )
            )
        );
 
        $currentStateId = $currentState ? $currentState->getStateId() : null;
        $options = new FieldsetLayout( [
            'items' => [
                new FieldLayout(
                    new RadioInputWidget( [
                        'name' => 'translatable-page-state',
                        'value' => 'ignored',
                        'selected' => $currentStateId === TranslatableBundleState::IGNORE
                    ] ),
                    [
                        'label' => $this->msg( 'tpt-translation-settings-ignore' )->text(),
                        'align' => 'inline',
                        'help' => $this->msg( 'tpt-translation-settings-ignore-hint' )->text(),
                        'helpInline' => true,
                    ]
                ),
                new FieldLayout(
                    new RadioInputWidget( [
                        'name' => 'translatable-page-state',
                        'value' => 'unstable',
                        'selected' => $currentStateId === null
                    ] ),
                    [
                        'label' => $this->msg( 'tpt-translation-settings-unstable' )->text(),
                        'align' => 'inline',
                        'help' => $this->msg( 'tpt-translation-settings-unstable-hint' )->text(),
                        'helpInline' => true,
                    ]
                ),
                new FieldLayout(
                    new RadioInputWidget( [
                        'name' => 'translatable-page-state',
                        'value' => 'proposed',
                        'selected' => $currentStateId === TranslatableBundleState::PROPOSE
                    ] ),
                    [
                        'label' => $this->msg( 'tpt-translation-settings-propose' )->text(),
                        'align' => 'inline',
                        'help' => $this->msg( 'tpt-translation-settings-propose-hint' )->text(),
                        'helpInline' => true,
                    ]
                ),
            ],
        ] );
 
        $out->addHTML( $options->toString() );
 
        $submitButton = new FieldLayout(
            new ButtonInputWidget( [
                'label' => $this->msg( 'tpt-translation-settings-save' )->text(),
                'type' => 'submit',
                'flags' => [ 'primary', 'progressive' ],
                'disabled' => $block !== null,
            ] )
        );
 
        $out->addHTML( $submitButton->toString() );
        $out->addHTML( Html::closeElement( 'form' ) );
    }
 
    private function handleTranslationState( Title $title, string $selectedState ): void {
        $validStateValues = [ 'ignored', 'unstable', 'proposed' ];
        $out = $this->getOutput();
        if ( !in_array( $selectedState, $validStateValues ) ) {
            throw new InvalidArgumentException( "Invalid translation state selected: $selectedState" );
        }
 
        $user = $this->getUser();
        if ( !$this->translatablePageView->canManageTranslationSettings( $title, $user ) ) {
            $this->showTranslationStateRestricted();
            return;
        }
 
        $bundleState = TranslatableBundleState::newFromText( $selectedState );
        if ( $selectedState === 'unstable' ) {
            $this->translatablePageStateStore->remove( $title );
        } else {
            $this->translatablePageStateStore->set( $title, $bundleState );
        }
 
        $this->displayStateInfoMessage( $title, $bundleState );
        $out->setPageTitle( $this->msg( 'tpt-translation-settings-page-title' )->text() );
        $out->addWikiMsg( 'tpt-list-pages-in-translations' );
    }
 
    private function addPageForm(
        Title $target,
        string $formClass,
        string $action,
        ?int $revision
    ): void {
        $formParams = [
            'method' => 'post',
            'action' => $this->getPageTitle()->getLocalURL(),
            'class' => $formClass
        ];
 
        $this->getOutput()->addHTML(
            Xml::openElement( 'form', $formParams ) .
            Html::hidden( 'do', $action ) .
            Html::hidden( 'title', $this->getPageTitle()->getPrefixedText() ) .
            ( $revision ? Html::hidden( 'revision', $revision ) : '' ) .
            Html::hidden( 'target', $target->getPrefixedText() ) .
            Html::hidden( 'token', $this->getContext()->getCsrfTokenSet()->getToken() )
        );
    }
 
    private function displayStateInfoMessage( Title $title, TranslatableBundleState $bundleState ): void {
        $stateId = $bundleState->getStateId();
        if ( $stateId === TranslatableBundleState::UNSTABLE ) {
            $infoMessage = $this->msg( 'tpt-translation-settings-unstable-notice' );
        } elseif ( $stateId === TranslatableBundleState::PROPOSE ) {
            $userHasPageTranslationRight = $this->getUser()->isAllowed( 'pagetranslation' );
            if ( $userHasPageTranslationRight ) {
                $infoMessage = $this->msg( 'tpt-translation-settings-proposed-pagetranslation-notice' )->params(
                    'https://www.mediawiki.org/wiki/Special:MyLanguage/' .
                    'Help:Extension:Translate/Page_translation_administration',
                    $title->getFullURL( 'action=edit' ),
                    SpecialPage::getTitleFor( 'PagePreparation' )
                        ->getFullURL( [ 'page' => $title->getPrefixedText() ] )
                );
            } else {
                $infoMessage = $this->msg( 'tpt-translation-settings-proposed-editor-notice' );
            }
        } else {
            $infoMessage = $this->msg( 'tpt-translation-settings-ignored-notice' );
        }
 
        $this->getOutput()->wrapWikiMsg( Html::noticeBox( '$1', '' ), $infoMessage );
    }
 
    private function getBlock( WebRequest $request, User $user, Title $title ): ?ErrorPageError {
        if ( $this->permissionManager->isBlockedFrom( $user, $title, !$request->wasPosted() ) ) {
            $block = $user->getBlock();
            if ( $block ) {
                return new UserBlockedError(
                    $block,
                    $user,
                    $this->getLanguage(),
                    $request->getIP()
                );
            }
 
            return new PermissionsError( 'pagetranslation', [ 'badaccess-group0' ] );
        }
 
        return null;
    }
 
    private function showTranslationStateRestricted(): void {
        $out = $this->getOutput();
        $out->wrapWikiMsg( Html::errorBox( "$1" ), 'tpt-translation-settings-restricted' );
        $out->addWikiMsg( 'tpt-list-pages-in-translations' );
    }
}