package org.litesoft.prioritizer.server.pos;

import java.util.*;

import org.litesoft.core.simpletypes.*;
import org.litesoft.core.typeutils.*;
import org.litesoft.core.util.*;
import org.litesoft.exceptions.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.orsup.transact.*;
import org.litesoft.prioritizer.client.support.*;
import org.litesoft.prioritizer.server.*;
import org.litesoft.security.*;

public class User extends UserGO implements SecurityUser<User>
{
    public User( Transaction pTransaction ) // Only used for New
    {
        super( pTransaction );
    }

    public User( ConstructionControl pConstructionControl )
    {
        super( pConstructionControl );
    }

    private boolean mDemo;

    @Override
    public Boolean getDemoUser()
    {
        return mDemo;
    }

    @Override
    protected void LLclearDemoUser()
    {
    }

    @Override
    public boolean isDemo()
    {
        return mDemo;
    }

    @Override
    public void setDemo()
    {
        mDemo = true;
    }

    @Override
    public String getHexPassword()
    {
        String zEncryptedPassword = LLgetPassword();
        return (zEncryptedPassword == null) ? null : Hex.toHex( zEncryptedPassword.getBytes() );
    }

    @Override
    protected void LLsetHexPassword( String pHexPassword )
    {
        LLsetPassword( (pHexPassword == null) ? null : new String( Hex.fromHex( pHexPassword ) ) );
    }

    @Override
    protected void LLclearHexPassword()
    {
    }

    @Override
    public String getFullName()
    {
        return ((Strings.deNull( getFirstName() ) + " " + Strings.deNull( getMiddleInitial() )).trim() + " " + Strings.deNull( getLastName() )).trim();
    }

    @Override
    protected void LLclearFullName()
    {
    }

    @Override
    public Boolean getVisibleToCurrentRestrictedResource()
    {
        UserXrefRestrictedResource zRestrictedResource = getCurrentRestrictedResource();

        return (zRestrictedResource != null) ? zRestrictedResource.getVisible() : null;
    }

    @Override
    protected void LLclearVisibleToCurrentRestrictedResource()
    {
    }

    @Override
    protected void LLsetVisibleToCurrentRestrictedResource( Boolean pVisibleToCurrentRestrictedResource )
    {
        if ( pVisibleToCurrentRestrictedResource != null )
        {
            UserXrefRestrictedResource zRestrictedResource = getCurrentRestrictedResource();

            if ( zRestrictedResource != null )
            {
                zRestrictedResource.setVisible( pVisibleToCurrentRestrictedResource );
            }
        }
    }

    private RestrictedResource mLastCurrentRestrictedResource;
    private UserXrefRestrictedResource mLastUserXrefRestrictedResource;

    @Override
    public UserXrefRestrictedResource getCurrentRestrictedResource()
    {
        if ( (mLastUserXrefRestrictedResource != null) && (getTransaction() != null) )
        {
            return mLastUserXrefRestrictedResource;
        }
        RestrictedResource zCurrentRestrictedResource = CurrentRestrictedResourceAccessor.get().getOptionalRestrictedResource();
        if ( zCurrentRestrictedResource != null )
        {
            if ( zCurrentRestrictedResource.equals( mLastCurrentRestrictedResource ) && zCurrentRestrictedResource.getRecordVersion().equals( mLastCurrentRestrictedResource.getRecordVersion() ) )
            {
                return mLastUserXrefRestrictedResource;
            }
            for ( UserXrefRestrictedResource zUserXrefRestrictedResource : getRestrictedResources() )
            {
                RestrictedResource zRestrictedResource = zUserXrefRestrictedResource.getRestrictedResource();
                if ( zCurrentRestrictedResource.equals( zRestrictedResource ) )
                {
                    mLastCurrentRestrictedResource = zRestrictedResource;
                    return mLastUserXrefRestrictedResource = zUserXrefRestrictedResource;
                }
            }
            // todo: Is Next Appropriate for Super Users?
            if ( getTransaction() != null )
            {
                mLastUserXrefRestrictedResource = new UserXrefRestrictedResource( getTransaction(), this, zCurrentRestrictedResource );
                mLastCurrentRestrictedResource = mLastUserXrefRestrictedResource.getRestrictedResource();
                return mLastUserXrefRestrictedResource;
            }
        }
        LLclearCurrentRestrictedResource();
        return null;
    }

    @Override
    protected void LLclearCurrentRestrictedResource()
    {
        mLastCurrentRestrictedResource = null;
        mLastUserXrefRestrictedResource = null;
    }

    public UserRestrictedResourcePair<User, RestrictedResource> loginToRestrictedResourceIfAcceptable( RestrictedResource pRestrictedResource )
    {
        Objects.assertNotNull( "RestrictedResource", pRestrictedResource );
        Object o = attemptRestrictedResourceLink( pRestrictedResource );
        if ( o instanceof UserRestrictedResourcePair )
        {
            return (UserRestrictedResourcePair<User, RestrictedResource>) o;
        }
        throw new DisplayableRuntimeException( "RestrictedResource Not Authorized" );
    }

    public UserRestrictedResourcePair<User, RestrictedResource> getLoginRestrictedResource( RestrictedResource pCurrentRestrictedResource )
    {
        Object o = attemptRestrictedResourceLink( pCurrentRestrictedResource );
        if ( o instanceof UserRestrictedResourcePair )
        {
            return (UserRestrictedResourcePair<User, RestrictedResource>) o;
        }
        @SuppressWarnings({"unchecked"}) List<RestrictedResource> zAuthorizedRestrictedResources = (List) o;
        RestrictedResource zLastRestrictedResource = getLastRestrictedResource();
        if ( zLastRestrictedResource != null )
        {
            for ( RestrictedResource zRestrictedResource : zAuthorizedRestrictedResources )
            {
                if ( zRestrictedResource.equals( zLastRestrictedResource ) )
                {
                    return new UserRestrictedResourcePair<User, RestrictedResource>( this, zLastRestrictedResource );
                }
            }
        }
        if ( zAuthorizedRestrictedResources.isEmpty() )
        {
            throw new DisplayableRuntimeException( "NoAuthorizedRestrictedResources" );
        }
        return new UserRestrictedResourcePair<User, RestrictedResource>( this, zAuthorizedRestrictedResources.get( 0 ) );
    }

    private Object attemptRestrictedResourceLink( RestrictedResource pRestrictedResource )
    {
        List<RestrictedResource> zAuthorizedRestrictedResources = new ArrayList<RestrictedResource>();
        for ( UserXrefRestrictedResource zUserXrefRestrictedResource : getRestrictedResources() )
        {
            if ( zUserXrefRestrictedResource.isLoginAllowed() )
            {
                RestrictedResource zRestrictedResource = zUserXrefRestrictedResource.getRestrictedResource();
                if ( zRestrictedResource.equals( pRestrictedResource ) )
                {
                    return new UserRestrictedResourcePair<User, RestrictedResource>( this, pRestrictedResource );
                }
                zAuthorizedRestrictedResources.add( zRestrictedResource );
            }
        }
        if ( canAccessAllRestrictedResources() )
        {
            if ( pRestrictedResource == null )
            {
                return zAuthorizedRestrictedResources;
            }
            Transaction zTransaction = getFinder().createTransaction();
            User zUser = copyInto( zTransaction );
            RestrictedResource zRestrictedResource = pRestrictedResource.copyInto( zTransaction );
            new UserXrefRestrictedResource( zTransaction, zUser, zRestrictedResource ).setVisible( false );
            zTransaction.commit();
            return new UserRestrictedResourcePair<User, RestrictedResource>( zUser, zRestrictedResource );
        }
        if ( zAuthorizedRestrictedResources.isEmpty() )
        {
            throw new DisplayableRuntimeException( "NoAuthorizedRestrictedResources" );
        }
        return zAuthorizedRestrictedResources;
    }

    public String acceptablePassword( String pPassword )
    {
        if ( !isDemo() )
        {
            if ( pPassword.length() < 8 )
            {
                String zCurrentPassword = Strings.noEmpty( getPassword() );
                if ( (zCurrentPassword == null) || (pPassword.length() < zCurrentPassword.length()) )
                {
                    return "Unacceptable New Password - Too Short";
                }
            }
        }
        return null;
    }

    public boolean validatePassword( String pPassword )
    {
        return isDemo() || Strings.deNull( pPassword ).trim().equals( getPassword() );
    }

    public RestrictedResource[] getAlternateRestrictedResourceOptions( RestrictedResource pRestrictedResource )
    {
        List<RestrictedResource> zOptions = new ArrayList<RestrictedResource>();
        for ( UserXrefRestrictedResource zUserXrefRestrictedResource : getRestrictedResources() )
        {
            RestrictedResource zRestrictedResource = zUserXrefRestrictedResource.getRestrictedResource();
            if ( !zRestrictedResource.equals( pRestrictedResource ) )
            {
                zOptions.add( zRestrictedResource );
            }
        }
        return zOptions.toArray( new RestrictedResource[zOptions.size()] );
    }

    public boolean canAccessAllRestrictedResources()
    {
        return UtilsCommon.isAnyTrue( getRestrictedResourceManage(), getSuperAdmin(), getHelpDeskMember() );
    }

    public static WhereClause getLimitToCurrentRestrictedResourceAndVisible()
    {
        // Add filter to where clause to only select based on RestrictedResource.
        RestrictedResource zRestrictedResource = CurrentRestrictedResourceAccessor.get().getRequiredRestrictedResource();
        WhereClauseFactory zWCF = WhereClauseFactory.INSTANCE;
        return zWCF.isIn( CD_ID, new SingleColumnSelect( UserXrefRestrictedResource.CD_User, //
                                                         UserXrefRestrictedResourceMetaData.INSTANCE, //
                                                         zWCF.and( zWCF.isEqual( UserXrefRestrictedResource.CD_RestrictedResource, zRestrictedResource ), //
                                                                   zWCF.isEqual( UserXrefRestrictedResource.CD_Visible, true ) ) ) );
    }

    @Override
    public TextLines getCurrentRestrictedResourceAllowedRoles()
    {
        return new TextLines( Role.OPTIONS ); // todo: Make work for real.
    }

    /**
     * Depends upon CurrentRestrictedResource.LastRole
     */
    @Override
    public String getLastRestrictedResourceRole()
    {
        UserXrefRestrictedResource zCurrentRestrictedResource = getCurrentRestrictedResource();
        if ( zCurrentRestrictedResource != null )
        {
            String zLastRole = zCurrentRestrictedResource.getLastRole();
            if ( zLastRole != null )
            {
                return zLastRole;
            }
        }
        return Role.EndUser.toString();
    }

    @Override
    protected void LLclearCurrentRestrictedResourceAllowedRoles()
    {
    }

    @Override
    protected void LLclearLastRestrictedResourceRole()
    {
    }

    @Override
    protected void LLsetLastRestrictedResourceRole( String pLastRestrictedResourceRole )
    {
        UserXrefRestrictedResource zCurrentRestrictedResource = getCurrentRestrictedResource();
        if ( zCurrentRestrictedResource != null )
        {
            zCurrentRestrictedResource.setLastRole( pLastRestrictedResourceRole );
        }
    }
}