<?php
if( !defined( 'MEDIAWIKI' )) die( -1 ); # guard against stray browsers


# API query engine to resolve the minder of a user page.
# http://reluk.ca/project/mailish/MailishUsername.xht#minderAPI
#
final class MailishMinder
{


    # Hook to add 'minder' as an 'inprop' request.
    #
    static function onAPIGetAllowedParams( &$module, &$params )
    {
        if( $module instanceof ApiQueryInfo )
        {
            $inpropDef = &$params['prop']; # definition of query parameter 'inprop'
            $inpropType = &$inpropDef[ApiBase::PARAM_TYPE];
              # type of query parameter 'inprop', a list of allowed values
            $inpropType[] = 'minder';
              # Extending the type with an additional value.  Should probably also modify
              # ApiQueryInfo.getCacheMode in order to allow caching of responses, but it
              # cannot easily be modified.
        }
        return true;
    }


    # Hook to service the 'minder' request.
    #
    static function onAPIQueryAfterExecute( &$module )
    {
        if( !( $module instanceof ApiQueryInfo )) return true;

      # $inprop = $module->getParameter( 'prop' );
      ## method is protected, so
        $params = $module->extractRequestParams();
        if( !array_key_exists( 'prop', $params )) return true;

        $inprop = $params['prop'];
        if( is_null( $inprop )) return true;

        if( !in_array( 'minder', $inprop, true )) return true; # minder not requested

        $result = $module->getResult();
        $data = $result->getData(); # read only
        if( !array_key_exists( 'query', $data )) return true;

        $query = &$data['query'];
        if( !array_key_exists( 'pages', $query )) return true;

        $pages = &$query['pages'];
        $minder = array();
        foreach( $pages as $pageID => &$page ) # key is page ID
        {
            if( !is_int( $pageID )) continue; # skip "_element" metadata key

            if( !array_key_exists( 'title', $page ))
            {
                self::addMinderWithErrorMessage( $result, $pageID, $minder, "id $pageID",
                  'missing title in query result' );
                continue;
            }

           # Namespace is User
           # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            if( !array_key_exists( 'ns', $page ))
            {
                self::addMinderWithErrorMessage( $result, $pageID, $minder, "id $pageID",
                  'missing ns in query result' );
                continue;
            }

            $ns = $page['ns'];
            $root = self::newRootTitle( $ns, $page['title'] );
            if( $ns != 2 )
            {
                self::addMinderWithFail( $result, $pageID, $minder, $root, 'mailishMinderFailNS' );
                continue;
            }

           # Root page exists
           # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            if( !$root->exists() )
            {
                self::addMinderWithFail( $result, $pageID, $minder, $root, 'mailishMinderFailPage' );
                continue;
            }

           # Root page sets Minder property
           # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            $minderValues = smwfGetStore()->getPropertyValues( SMWDIWikiPage::newFromTitle($root),
              SMWDIProperty::newFromUserLabel('Minder') );
            if( !$minderValues )
            {
                self::addMinderWithFail( $result, $pageID, $minder, $root,
                  'mailishMinderFailMinder' );
                continue;
            }

           # Just one minder
           # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            $minderCount = count( $minderValues );
            if( $minderCount > 1 )
            {
                self::addMinderWithFail( $result, $pageID, $minder, $root,
                  'mailishMinderFailMinderMulti' );
                continue;
            }

           # Minder is user
           # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            $minderTitle = $minderValues[0]->getTitle();
            $minderNS = $minderTitle->getNamespace();
            if( $minderNS != 2 )
            {
                self::addMinderWithFailMessage( $result, $pageID, $minder, $root,
                  wfMessage('mailishMinderFailMinderNS',$minderUsername) );
                continue;
            }

           # Minder is real user, not a pipe
           # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            $minderUsername = $minderTitle->getText();
            if( self::isPipeName( $minderUsername ))
            {
                self::addMinderWithFailMessage( $result, $pageID, $minder, $root,
                  wfMessage('mailishMinderFailMinderPipe',$minderUsername) );
                continue;
            }

           # Page user exists
           # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            $username = $root->getText(); # assume already canonical, per User::getCanonicalName
            $row = wfGetDB(DB_SLAVE)->selectRow( /*tables*/'user', # slave is read-only
              /*vars*/array('user_email','user_email_authenticated'),
              /*cond, equality*/array('user_name'=>$username) );
            if( !$row )
            {
                self::addMinderWithFailMessage( $result, $pageID, $minder, $root,
                  wfMessage('mailishMinderFailUser',$username) );
                continue;
            }

           # User has email address in preferences
           # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            $userEmail = $row->user_email;
            if( !$userEmail )
            {
                self::addMinderWithFailMessage( $result, $pageID, $minder, $root,
                  wfMessage('mailishMinderFailEmail',$username) );
                continue;
            }

           # Email address is authenticated
           # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            $userEmailTimestamp = $row->user_email_authenticated;
            if( is_null( $userEmailTimestamp ))
            {
                self::addMinderWithFailMessage( $result, $pageID, $minder, $root,
                  wfMessage('mailishMinderFailEmailAuth',$username) );
                continue;
            }

           # Email address matches minder
           # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            $minderUsernameAuth = MailishUsername::emailToUsername( $userEmail );
            if( $minderUsername != $minderUsernameAuth )
            {
                self::addMinderWithFailMessage( $result, $pageID, $minder, $root,
                  wfMessage('mailishMinderFailMinderMatch',$minderUsernameAuth,$minderUsername) );
                continue;
            }

           # - - -
            $minder['username'] = $minderUsername;
            $result->addValue( array('query','pages',$pageID), 'minder', $minder );
        }
        return true;
    }


##### P r i v a t e ######################################################################


    private static function addMinder( &$result, $pageID, &$minder )
    {
        $result->addValue( array('query','pages',$pageID), 'minder', $minder );
    }


    private static function addMinderWithFail( &$result, $pageID, &$minder, $root, $messageKey )
    {
        self::addMinderWithFailMessage( $result, $pageID, $minder, $root, wfMessage($messageKey) );
    }


    private static function addMinderWithFailMessage( &$result, $pageID, &$minder, $root, $message )
    {
        $minder['fail'] = self::failPrefix($root) . $message;
        self::addMinder( $result, $pageID, $minder );
    }


    private static function addMinderWithErrorMessage( &$result, $pageID, &$minder, $root, $message )
    {
        self::addMinderWithFailMessage( $result, $pageID, $minder, $root,
          'Internal error: ' . $message );
    }


    private static function failPrefix( $root )
    {
        return wfMessage( 'mailishMinderFailPrefix', $root->getPrefixedText() );
    }


    private static function newRootTitle( $ns, $prefixedText )
    {
        # modified from v. 20 Title::getRootText
        if( MWNamespace::hasSubpages( $ns )) $prefixedText = strtok( $prefixedText, '/' ); # to root
        return Title::newFromText( $prefixedText ); # automatically strips prefix
    }


    private static function isPipeName( $username )
    {
        $prefix = wfMessage( 'Vo-pipePrefix' );
        if( !$prefix ) return false;

        $suffix = wfMessage( 'Vo-pipeSuffix' );
        if( !$suffix ) return false;

        return strlen($username) > strlen($prefix) + strlen($suffix)
          && MailishUtil::startsWith( $username, $prefix )
          && MailishUtil::endsWith( $username, $suffix );
    }


}