package org.litesoft.security;

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

import java.util.*;

@SuppressWarnings({"UnusedDeclaration"})
public abstract class SecurityUserViewPoServerVoDataProvider<VO extends SecurityUserView<VO>, PO extends SecurityUser<PO>,
        RRPO extends SecurityRestrictedResource<RRPO>>
        extends PoServerVoDataProvider<VO> {
    private String mDefaultUserLoginEmail = ConstrainTo.significantOrNull( 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 = ConstrainTo.significantOrNull( pUserView.getNewPassword() );
        String zConfirmPassword = ConstrainTo.significantOrNull( 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();
            Confirm.isNotNull( "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, ServerStores.getMaster().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( ServerStores.getMaster().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( ConstrainTo.notNull( 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 );
}