package org.litesoft.security;

import org.litesoft.commonfoundation.exceptions.*;
import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.bo.views.*;
import org.litesoft.bo.views.communication.*;
import org.litesoft.bo.views.server.*;
import org.litesoft.core.*;
import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.orsup.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.transact.*;
import org.litesoft.sql.*;

@SuppressWarnings({"UnusedDeclaration"})
public abstract class SecurityUserViewPoServerVoDataProvider<VO extends SecurityUserView<VO>, PO extends SecurityUser<PO>, RRPO extends SecurityRestrictedResource<RRPO>> extends PoServerVoDataProvider<VO>
{
    private String mDefaultUserLoginEmail = Strings.noEmpty( System.getProperty( "User" ) );

    protected String getDefaultUserLoginEmail()
    {
        String zInitialUserEmail = mDefaultUserLoginEmail;
        mDefaultUserLoginEmail = null;
        return ((zInitialUserEmail != null) && (null == cursoryEmailCheck( zInitialUserEmail, SecurityUserViewNames.aLogonEmail ))) ? zInitialUserEmail : null;
    }

    private final String[] mDemoUserEmails;
    private final Set<String> mSetOfDemoUserEmails;

    protected SecurityUserViewPoServerVoDataProvider( VoMetaData<VO> pVOMetaData, MetaDataStore pMetaDataStore, String... pDemoUserEmails )
    {
        super( pVOMetaData, pMetaDataStore );
        mSetOfDemoUserEmails = new HashSet<String>( Arrays.asList( mDemoUserEmails = pDemoUserEmails ) );
    }

    @Override
    protected void LLinitialize()
    {
        super.LLinitialize();

        register( new SecurityUserViewServerFunctionLogin<VO>() );
        register( new SecurityUserViewServerFunctionLogout<VO>() );
        register( new SecurityUserViewServerFunctionSwitchRestrictedResources<VO>() );
        register( new SecurityUserViewServerFunctionChangePassword<VO>() );
        register( new SecurityUserViewServerFunctionValidatePassword<VO>() );
        register( new SecurityUserViewServerFunctionValidateLogonEmailAvailable<VO>() );
        register( new SecurityUserViewServerFunctionNextDemoLoginUser<VO>() );
        register( new SecurityUserViewServerFunctionFetchCurrentLoginUser<VO>() );
    }

    public SCresult changePassword( SecurityUserView pUserView )
    {
        String zLogonEmail = pUserView.getLogonEmail();
        String zCurrentPassword = pUserView.getCurrentPassword();
        String zNewPassword = Strings.noEmpty( pUserView.getNewPassword() );
        String zConfirmPassword = Strings.noEmpty( pUserView.getConfirmPassword() );

        String zError = cursoryPasswordCheck( zCurrentPassword, SecurityUserViewNames.aCurrentPassword );
        if ( null == zError )
        {
            if ( null == (zError = cursoryPasswordCheck( zNewPassword, SecurityUserViewNames.aNewPassword )) )
            {
                if ( null == (zError = cursoryPasswordCheck( zConfirmPassword, SecurityUserViewNames.aConfirmPassword )) )
                {
                    if ( !zNewPassword.equals( zConfirmPassword ) )
                    {
                        zError = "New & Confirm Passwords do not match";
                    }
                    else
                    {
                        while ( zError == null )
                        {
                            SecurityUser<PO> zUser = getUserByEmailFromCurrentDS( zLogonEmail );
                            if ( (zUser == null) || !zUser.validatePassword( zCurrentPassword ) )
                            {
                                zError = "Invalid Credentials";
                            }
                            else if ( null == (zError = zUser.acceptablePassword( zNewPassword )) )
                            {
                                Transaction zTransaction = DataStoreLocator.get().getUnfilteredFinder().createTransaction();
                                zUser = zUser.copyInto( zTransaction );
                                zUser.setPassword( zNewPassword );
                                try
                                {
                                    zTransaction.commit();
                                    return VOSC.result( createView( zUser, false ) );
                                }
                                catch ( ConcurrentPOModificationException e )
                                {
                                    // Loop...
                                }
                                catch ( RuntimeException e )
                                {
                                    LOGGER.warn.log( e );
                                    zError = e.getMessage();
                                }
                            }
                        }
                    }
                }
            }
        }
        return VOSC.result( zError );
    }

    public String validatePassword( SecurityUserView pUserView )
    {
        String zCurrentPassword = pUserView.getCurrentPassword();
        String zError = cursoryPasswordCheck( zCurrentPassword, SecurityUserViewNames.aCurrentPassword );
        if ( null == zError )
        {
            zError = "Invalid";
            SecurityUser<PO> zUser = getUserByEmailFromCurrentDS( pUserView.getLogonEmail() );
            if ( (zUser != null) && zUser.validatePassword( zCurrentPassword ) )
            {
                return null;
            }
        }
        return zError;
    }

    public SecurityUserView validateLogonEmailAvailable( String pLogonEmail )
    {
        String zError = cursoryEmailCheck( pLogonEmail, SecurityUserViewNames.aLogonEmail );
        if ( zError != null )
        {
            throw new DisplayableRuntimeException( zError );
        }
        SecurityUser<PO> zUser = getUserByEmailFromCurrentDS( pLogonEmail );
        return createView( zUser, false );
    }

    public SecurityUserView loginUser( String pLogonEmail, String pPassword )
    {
        String zError = cursoryEmailCheck( pLogonEmail, SecurityUserViewNames.aLogonEmail );
        if ( null == zError )
        {
            if ( null == (zError = cursoryPasswordCheck( pPassword, SecurityUserViewNames.aCurrentPassword )) )
            {
                zError = "Invalid Credentials";
                SecurityUser<PO> zUser = getUserByEmailFromMasterDS( pLogonEmail );
                if ( zUser != null )
                {
                    if ( zUser.validatePassword( pPassword ) )
                    {
                        return updateLoggedInUserFromMasterDS( zUser );
                    }
                }
            }
        }
        throw new DisplayableRuntimeException( zError );
    }

    public SecurityUserView loginDefaultUser( String pLogonEmail )
    {
        try
        {
            SecurityUser<PO> zUser = getUserByEmailFromMasterDS( pLogonEmail );
            if ( zUser != null )
            {
                return updateLoggedInUserFromMasterDS( zUser );
            }
        }
        catch ( RuntimeException e )
        {
            LOGGER.error.log( e );
        }
        return null;
    }

    abstract public SecurityUserView switchRestrictedResources( SecurityRestrictedResourceView pRestrictedResourceView );

    private SecurityUserView updateLoggedInUserFromMasterDS( SecurityUser<PO> pUser )
    {
        if ( !pUser.isDemo() )
        {
            initializeRealDB();
        }
        else
        {
            initializeDemoDB();
            Objects.assertNotNull( "Demo User Refreshed", pUser = getUserByEmailFromCurrentDS( pUser.getLogonEmail() ) );
        }
        return finiUserLogin( pUser );
    }

    public SecurityUserView nextDemoUserView()
    {
        initializeDemoDB();
        int zNextIndex = findCurrentDemoIndex( currentLoggedInUserView() ) + 1;
        for ( int i = 2 + mDemoUserEmails.length; --i > 0; zNextIndex++ )
        {
            if ( mDemoUserEmails.length <= zNextIndex )
            {
                zNextIndex = 0;
            }
            SecurityUser<PO> zUser = getUserByEmailFromCurrentDS( mDemoUserEmails[zNextIndex] );
            if ( zUser != null )
            {
                zUser.setDemo();
                return finiUserLogin( zUser );
            }
        }
        throw new IllegalStateException( "No Demo Users!" );
    }

    private void initializeRealDB()
    {
        ServerContext.get().getServerStore().set( DataStore.class, ServerContext.getMasterServerStore().get( DataStore.class ) ); // Master DS
    }

    private void initializeDemoDB()
    {
        ServerContext zContext = ServerContext.get();
        DemoDataStoreManager.Struct zDemoDS = DemoDataStoreManager.getDemoDS( zContext.getContextID() ); // Demo DS
        zContext.getServerStore().set( DataStore.class, zDemoDS.getDataStore() );
        if ( zDemoDS.isEmptyDemo() )
        {
            populateDemoDS();
        }
    }

    abstract public SecurityUserView<VO> currentLoggedInUserView();

    abstract public void logoutUser();

    abstract protected SecurityUserView finiUserLogin( SecurityUser<PO> pUser );

    private SecurityUser<PO> getUserByEmailFromMasterDS( String pLogonEmail )
    {
        return getUserByEmail( ServerContext.getMasterServerStore().get( DataStore.class ).getUnfilteredFinder(), pLogonEmail );
    }

    private SecurityUser<PO> getUserByEmailFromCurrentDS( String pLogonEmail )
    {
        return getUserByEmail( DataStoreLocator.get().getUnfilteredFinder(), pLogonEmail );
    }

    private SecurityUser<PO> getUserByEmail( Finder pFinder, String pLogonEmail )
    {
        SecurityUser<PO> zUser = findUserByEmail( pFinder, pLogonEmail );
        if ( isUserDemo( zUser ) )
        {
            zUser.setDemo();
        }
        return zUser;
    }

    private boolean isUserDemo( SecurityUser<PO> pUser )
    {
        return ((pUser != null) && mSetOfDemoUserEmails.contains( Strings.deNull( pUser.getLogonEmail() ).toLowerCase() ));
    }

    private int findCurrentDemoIndex( SecurityUserView pUser )
    {
        if ( pUser == null )
        {
            return 0;
        }
        int i = mDemoUserEmails.length;
        while ( --i >= 0 )
        {
            if ( mDemoUserEmails[i].equalsIgnoreCase( pUser.getLogonEmail() ) )
            {
                return i;
            }
        }
        return i;
    }

    private void populateDemoDS()
    {
        DataLoader.INSTANCE.loadDemoData();
    }

    abstract protected SecurityUser<PO> findUserByEmail( Finder pFinder, String pLogonEmail );
}