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

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

import java.util.*;

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

    @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;
    }
}