package org.litesoft.prioritizer.server.boviews.podataproviders;

import java.util.*;

import org.litesoft.bo.views.*;
import org.litesoft.bo.views.server.*;
import org.litesoft.exceptions.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.orsup.transact.*;
import org.litesoft.prioritizer.client.boviews.*;
import org.litesoft.prioritizer.server.*;
import org.litesoft.prioritizer.server.pos.*;
import org.litesoft.security.*;

public class UserViewPoServerVoDataProvider extends SecurityUserViewPoServerVoDataProvider<UserView, User, RestrictedResource>
{
    public UserViewPoServerVoDataProvider( MetaDataStore pMetaDataStore )
    {
        super( UserViewMetaData.getInstance(), pMetaDataStore, //
               "dm@richasp.com", // ........... Dee Man
               "hdeskman@richasp.com", // ..... Helpy Deskman
               "slick@richasp.com", // ........ Slick Salesman
               //
               "akern@testsite.com", // ....... Anthony Kern
               "dsteele@testsite.com", // ..... Donald Steele
               "saly@testsite.com" // ........ Sally Operator
        );
    }

    @Override
    protected SecurityUser<User> findUserByEmail( Finder pFinder, String pLogonEmail )
    {
        return pFinder.findOne( User.class, WCF.isEqual( User.CD_LogonEmail, pLogonEmail ) );
    }

    @Override
    protected WhereClause augment_getMatchingVOs( WhereClause pWhereClause )
    {
        SecurityUser<User> zUser = CurrentUserAccessor.get().getRequiredUser();
        if ( !zUser.canAccessAllRestrictedResources() ) // If no user it will blow up with a null pointer exception which is appropriate.
        {
            pWhereClause = WCF.and( pWhereClause, User.getLimitToCurrentRestrictedResourceAndVisible() ); // Add filter to where clause to only select based on RestrictedResource.
        }
        return super.augment_getMatchingVOs( pWhereClause );
    }

    @Override
    public UserView currentLoggedInUserView()
    {
        return CurrentUserAccessor.get().getUserView( getDefaultUserLoginEmail() );
    }

    @Override
    public void logoutUser()
    {
        CurrentUserAccessor.get().logout();
        CurrentRestrictedResourceAccessor.get().logout();
    }

    @Override
    public SecurityUserView switchRestrictedResources( SecurityRestrictedResourceView pRestrictedResourceView )
    {
        User zUser = CurrentUserAccessor.get().getRequiredUser();
        RestrictedResource zRestrictedResource = (RestrictedResource) getNotUsDataProvider( RestrictedResourceView.class ).getExistingPO( DataStoreLocator.get().getUnfilteredFinder(), (RestrictedResourceView) pRestrictedResourceView );
        if ( zRestrictedResource == null )
        {
            throw new DisplayableRuntimeException( "RestrictedResourceNotFound", pRestrictedResourceView.toString() );
        }
        UserRestrictedResourcePair<User, RestrictedResource> zPair = zUser.loginToRestrictedResourceIfAcceptable( zRestrictedResource );
        return finiUserLogin( zPair.getUser(), zPair.getRestrictedResource() );
    }

    @Override
    protected SecurityUserView finiUserLogin( SecurityUser<User> pUser )
    {
        return finiUserLogin( pUser, CurrentRestrictedResourceAccessor.get().getOptionalRestrictedResource() );
    }

    protected SecurityUserView finiUserLogin( SecurityUser<User> pUser, SecurityRestrictedResource<RestrictedResource> pRestrictedResource )
    {
        UserRestrictedResourcePair zUserRestrictedResourcePair = ((User) pUser).getLoginRestrictedResource( (RestrictedResource) pRestrictedResource );
        User zUser = (User) zUserRestrictedResourcePair.getUser();
        RestrictedResource zRestrictedResource = (RestrictedResource) zUserRestrictedResourcePair.getRestrictedResource();
        CurrentRestrictedResourceAccessor zRestrictedResourceAccessor = CurrentRestrictedResourceAccessor.get();
        zRestrictedResourceAccessor.updateRestrictedResource( zRestrictedResource );
        if ( !zRestrictedResource.equals( zUser.getLastRestrictedResource() ) )
        {
            Transaction zTransaction = zUser.getFinder().createTransaction();
            zUser = zUser.copyInto( zTransaction );
            zUser.setLastRestrictedResource( zRestrictedResource );
            zTransaction.commit();
        }
        zRestrictedResourceAccessor.updateRestrictedResource( zRestrictedResource );
        UserView zUserView = CurrentUserAccessor.get().updateUser( zUser );
        zUserView.setCurrentRestrictedResource( zRestrictedResourceAccessor.getRestrictedResourceView() );
        if ( !zUser.canAccessAllRestrictedResources() )
        {
            zUserView.setAlternateRestrictedResourceOptions( convertToRestrictedResourceOptions( zUser.getAlternateRestrictedResourceOptions( zRestrictedResource ) ) );
        }
        return zUserView;
    }

    private AlternateRestrictedResourceOption[] convertToRestrictedResourceOptions( RestrictedResource[] pRestrictedResources )
    {
        AlternateRestrictedResourceOption[] rv = new AlternateRestrictedResourceOption[pRestrictedResources.length];
        PoServerVoDataProvider<RestrictedResourceView> zRestrictedResourceViewDP = getNotUsDataProvider( RestrictedResourceView.class );
        for ( int i = 0; i < pRestrictedResources.length; i++ )
        {
            rv[i] = zRestrictedResourceViewDP.createView( pRestrictedResources[i], false );
        }
        Arrays.sort( rv );
        return rv;
    }
}