public class FingerprintLogin extends UseCase<FingerprintLogin.FingerprintResult, FingerprintLogin.Params> {
    private final Context context;
    private final AccountsDataSource accountLocalDataSource;
    private CancellationSignal cancellationSignal;
    private KeyStore mKeyStore;
    private Cipher mCipher;


    @Inject
    FingerprintLogin(ThreadExecutor threadExecutor, PostExecutionThread postExecutionThread, Context context, AccountsDataSource accountLocalDataSource) {
        super(threadExecutor, postExecutionThread);
        this.context = context;
        this.accountLocalDataSource = accountLocalDataSource;
    }

    @Override
    @DebugLog
    protected Observable<FingerprintResult> buildUseCaseObservable(Params params) {
        return Observable.create(subscriber -> {
            if (accountLocalDataSource.init(params.activity)) {
                if (params.user != null)
                    accountLocalDataSource.updateAccountRx(params.user);
            }

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                KeyguardManager mKeyguardManager = context.getSystemService(KeyguardManager.class);
                android.hardware.fingerprint.FingerprintManager mFingerprintManager = context.getSystemService(android.hardware.fingerprint.FingerprintManager.class);

                SpassFingerprint.IdentifyListener identifyListener = new SpassFingerprint.IdentifyListener() {
                    @Override
                    @DebugLog
                    public void onFinished(int eventStatus) {
                        if (!subscriber.isDisposed()) {
                            switch (eventStatus) {
                                case SpassFingerprint.STATUS_AUTHENTIFICATION_SUCCESS:
                                    subscriber.onNext(new FingerprintResult(FingerprintStatus.onAuthenticationSucceeded));
                                    break;
                                case SpassFingerprint.STATUS_AUTHENTIFICATION_FAILED:
                                    subscriber.onNext(new FingerprintResult(FingerprintStatus.onAuthenticationFailed));
                                    break;
                            }
                        }

                    }

                    @Override
                    @DebugLog
                    public void onReady() {

                    }

                    @Override
                    @DebugLog
                    public void onStarted() {
                    }

                    @Override
                    @DebugLog
                    public void onCompleted() {

                    }
                };

                android.hardware.fingerprint.FingerprintManager.AuthenticationCallback authenticationCallback = new android.hardware.fingerprint.FingerprintManager.AuthenticationCallback() {
                    @Override
                    @DebugLog
                    public void onAuthenticationError(int errMsgId, CharSequence errString) {
                        if (!subscriber.isDisposed()) {
                            if (errMsgId == android.hardware.fingerprint.FingerprintManager.FINGERPRINT_ERROR_LOCKOUT ||
                                    errMsgId == android.hardware.fingerprint.FingerprintManager.FINGERPRINT_ERROR_TIMEOUT) {
                                try {
                                    if (accountLocalDataSource.init(params.activity))
                                        accountLocalDataSource.removeAccounts();
                                } catch (AccountManagerNotInitException e) {
                                    subscriber.onError(e);
                                }
                                subscriber.onNext(new FingerprintResult(FingerprintStatus.onSignOut));
                            }
                            subscriber.onNext(new FingerprintResult(FingerprintStatus.onAuthenticationError, errString.toString()));
                        }

                    }

                    @Override
                    @DebugLog
                    public void onAuthenticationHelp(int helpMsgId, CharSequence helpString) {
                        if (!subscriber.isDisposed()) {
                            subscriber.onNext(new FingerprintResult(FingerprintStatus.onAuthenticationHelp, helpString.toString()));
                        }
                    }

                    @Override
                    @DebugLog
                    public void onAuthenticationFailed() {
                        if (!subscriber.isDisposed()) {
                            subscriber.onNext(new FingerprintResult(FingerprintStatus.onAuthenticationFailed));
                        }
                    }

                    @Override
                    @DebugLog
                    public void onAuthenticationSucceeded(android.hardware.fingerprint.FingerprintManager.AuthenticationResult result) {
                        if (!subscriber.isDisposed()) {
                            subscriber.onNext(new FingerprintResult(FingerprintStatus.onAuthenticationSucceeded));
                            subscriber.onComplete();
                        }
                        stopListening();
                    }

                };

                if (!mKeyguardManager.isKeyguardSecure()) {
                    if (!subscriber.isDisposed()) {
                        subscriber.onNext(new FingerprintResult(FingerprintStatus.onLockScreenNotEnabled));
                    }
                }

                if (ActivityCompat.checkSelfPermission(context, Manifest.permission.USE_FINGERPRINT) != PackageManager.PERMISSION_GRANTED) {
                    if (!subscriber.isDisposed()) {
                        subscriber.onNext(new FingerprintResult(FingerprintStatus.onFingerprintNotEnabledPermission));

                    }
                }

                if (!mFingerprintManager.isHardwareDetected()) {
                    if (!initializeSpassFingerprint(context, identifyListener)) {
                        if (!mFingerprintManager.hasEnrolledFingerprints()) {
                            if (!subscriber.isDisposed()) {
                                subscriber.onNext(new FingerprintResult(FingerprintStatus.onNoFingerprintsAreRegistered));

                            }
                        }
                    }
                } else {

                    if (!subscriber.isDisposed()) {
                        subscriber.onNext(new FingerprintResult(FingerprintStatus.onFingerpintInit));
                    }

                    if (params.user != null && params.user.getLowerJidString() != null) {
                        cancellationSignal = new CancellationSignal();
                        if (fingerKey(params.user.getLowerJidString())) {
                            mFingerprintManager.authenticate(new android.hardware.fingerprint.FingerprintManager.CryptoObject(mCipher), cancellationSignal, 0, authenticationCallback, null);
                            if (!subscriber.isDisposed()) {
                                subscriber.onNext(new FingerprintResult(FingerprintStatus.onStartListening));
                            }
                        } else {
                            if (!subscriber.isDisposed()) {
                                subscriber.onNext(new FingerprintResult(FingerprintStatus.onAuthenticationFailed));
                                subscriber.onComplete();
                            }
                        }
                    } else {
                        if (!subscriber.isDisposed()) {
                            subscriber.onComplete();
                        }
                    }
                }
            } else {
                if (!subscriber.isDisposed()) {
                    subscriber.onNext(new FingerprintResult(FingerprintStatus.onNoFingerprintsAreRegistered));
                    subscriber.onComplete();
                }
            }
        });
    }

    @DebugLog
    private boolean initializeSpassFingerprint(Context context, SpassFingerprint.IdentifyListener mSpassIdentifyListener) {
        Spass mSpass = new Spass();
        try {
            mSpass.initialize(context);
            if (mSpass.isFeatureEnabled(Spass.DEVICE_FINGERPRINT)) {
                SpassFingerprint mSpassFingerprint = new SpassFingerprint(context);
                mSpassFingerprint.startIdentifyWithDialog(context, mSpassIdentifyListener, false);
                return true;
            } else {
                return false;
            }
        } catch (SsdkUnsupportedException e) {
            return false;
        }
    }


    /**
     * Checks existence of the fingerKey key by its name.
     *
     * @param keyName the fingerprint key name
     * @return true if fingerprint key found, else false
     */
    @DebugLog
    private boolean fingerKey(String keyName) {
        if (Build.VERSION.SDK_INT < 23) {
            return false;
        }
        try {
            mKeyStore = KeyStore.getInstance("AndroidKeyStore");
            KeyGenerator mKeyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore");

            //Initialize the KeyGenerator
            mKeyGenerator.init(new
                    //Specify the operation(s) this key can be used for//
                    KeyGenParameterSpec.Builder(keyName,
                    KeyProperties.PURPOSE_ENCRYPT |
                            KeyProperties.PURPOSE_DECRYPT)
                    .setBlockModes(KeyProperties.BLOCK_MODE_CBC)
                    //Configure this key so that the user has to confirm their identity with a fingerprint each time they want to use it//
                    .setUserAuthenticationRequired(true)
                    .setEncryptionPaddings(
                            KeyProperties.ENCRYPTION_PADDING_PKCS7)
                    .build());

            mKeyGenerator.generateKey();

            mCipher = Cipher.getInstance(KeyProperties.KEY_ALGORITHM_AES + "/"
                    + KeyProperties.BLOCK_MODE_CBC + "/"
                    + KeyProperties.ENCRYPTION_PADDING_PKCS7);
            mKeyStore.load(null);
            return initCipher(mCipher, keyName);
        } catch (NoSuchAlgorithmException | NoSuchProviderException | KeyStoreException | CertificateException | NoSuchPaddingException | InvalidAlgorithmParameterException | IOException e) {
            return false;
        }
    }


    @DebugLog
    private boolean initCipher(Cipher cipher, String keyName) {
        if (Build.VERSION.SDK_INT >= 23) {
            try {
                mKeyStore.load(null);
                SecretKey key = (SecretKey) mKeyStore.getKey(keyName, null);
                cipher.init(Cipher.ENCRYPT_MODE, key);
                return true;
            } catch (KeyPermanentlyInvalidatedException e) {
                return false;
            } catch (KeyStoreException | CertificateException | UnrecoverableKeyException | IOException
                    | NoSuchAlgorithmException | InvalidKeyException e) {
                throw new RuntimeException("Failed to start Cipher", e);
            }
        }
        return false;
    }

    @DebugLog
    private void stopListening() {
        if (cancellationSignal != null) {
            cancellationSignal.cancel();
            cancellationSignal = null;
        }
    }


    public enum FingerprintStatus {
        onAuthenticationFailed,
        onAuthenticationSucceeded,
        onAuthenticationError,
        onStartListening,
        onSignOut,
        onAuthenticationHelp,
        onFingerpintInit,
        onLockScreenNotEnabled,
        onFingerprintNotEnabledPermission,
        onNoFingerprintsAreRegistered,
        onFingerprintNoHardwareDetected,
        onFingerprintNotSet,
        onFinish
    }

    public static final class Params {
        private final User user;
        private final BaseActivity activity;

        Params(BaseActivity activity) {
            this.user = null;
            this.activity = activity;
        }

        Params(User user, BaseActivity activity) {
            this.user = user;
            this.activity = activity;
        }

        public @DebugLog
        static Params forFingerpintLogin(BaseActivity activity) {
            return new Params(activity);
        }

        public @DebugLog
        static Params forFingerpintLogin(User user, BaseActivity activity) {
            return new Params(user, activity);
        }
    }

    public class FingerprintResult {
        FingerprintStatus status;
        String message;

        @DebugLog
        public FingerprintResult(FingerprintStatus status, String message) {
            this.status = status;
            this.message = message;
        }

        @DebugLog
        public FingerprintResult(FingerprintStatus status) {
            this.status = status;
        }

        @DebugLog
        public FingerprintStatus getStatus() {
            return status;
        }

        @DebugLog
        public void setStatus(FingerprintStatus status) {
            this.status = status;
        }

        @DebugLog
        public String getMessage() {
            return message;
        }

        @DebugLog
        public void setMessage(String message) {
            this.message = message;
        }
    }
}