'use strict';

var exec = require('cordova/exec');

var SERVICE = 'BluememeUtils';
var EVENT_PREFIX = 'bluememeutils.';
var eventHandlers = Object.create(null);

function noop() {}

function isFunction(value) {
    return typeof value === 'function';
}

function callbackOrNoop(callback) {
    return isFunction(callback) ? callback : noop;
}

function asWifiOptions(input) {
    if (typeof input === 'string') {
        return { ssid: input };
    }
    return input || {};
}

function call(action, args, success, error) {
    exec(callbackOrNoop(success), callbackOrNoop(error), SERVICE, action, args || []);
}

function noArgs(action) {
    return function (success, error) {
        call(action, [], success, error);
    };
}

function oneArg(action, normalize) {
    return function (value, success, error) {
        call(action, [normalize ? normalize(value) : value], success, error);
    };
}

function isPermissionGranted(permission) {
    return !!permission && (permission.enabled === true || permission.granted === true);
}

function permissionError(type, permission) {
    return {
        code: 'PERMISSION_REQUIRED',
        message: type + ' permission is required.',
        permission: permission || null
    };
}

function createCustomEvent(name, detail) {
    var eventName = EVENT_PREFIX + name;

    if (typeof window.CustomEvent === 'function') {
        return new window.CustomEvent(eventName, { detail: detail });
    }

    var event = document.createEvent('CustomEvent');
    event.initCustomEvent(eventName, false, false, detail);
    return event;
}

function dispatchLocalEvent(event) {
    if (!event || !event.type) {
        return;
    }

    var handlers = eventHandlers[event.type] || [];
    handlers.slice().forEach(function (handler) {
        try {
            handler(event);
        } catch (ex) {
            setTimeout(function () {
                throw ex;
            }, 0);
        }
    });

    if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function') {
        window.dispatchEvent(createCustomEvent(event.type, event));
    }
}

function ensurePushPermission(success, error) {
    var onSuccess = callbackOrNoop(success);
    var onError = callbackOrNoop(error);

    api.getPushPermissionStatus(function (status) {
        if (isPermissionGranted(status)) {
            onSuccess(status);
            return;
        }

        api.requestPushPermission(function () {
            api.getPushPermissionStatus(function (updatedStatus) {
                if (isPermissionGranted(updatedStatus)) {
                    onSuccess(updatedStatus);
                    return;
                }
                onError(permissionError('notification', updatedStatus));
            }, onError);
        }, onError);
    }, onError);
}

function getFirebaseTokenWithPermission(success, error) {
    var onSuccess = callbackOrNoop(success);
    var onError = callbackOrNoop(error);

    ensurePushPermission(function (permission) {
        api.getFirebaseToken(function (result) {
            if (result && typeof result === 'object') {
                result.permission = permission;
            }
            onSuccess(result);
        }, onError);
    }, onError);
}

var api = {
    getDeviceInfo: noArgs('getDeviceInfo'),

    saveWifi: oneArg('saveWifi', asWifiOptions),

    connectWifi: oneArg('connectWifi', asWifiOptions),

    disconnectWifi: noArgs('disconnectWifi'),

    removeWifi: oneArg('removeWifi', asWifiOptions),

    requestWifiPermission: noArgs('requestWifiPermission'),

    isBiometricAvailable: noArgs('isBiometricAvailable'),

    unlockWithBiometrics: oneArg('unlockWithBiometrics', function (options) {
        return options || {};
    }),

    requestPushPermission: noArgs('requestPushPermission'),

    getPushPermissionStatus: noArgs('getPushPermissionStatus'),

    ensurePushPermission: ensurePushPermission,

    getFirebaseToken: noArgs('getFirebaseToken'),

    getFirebaseTokenWithPermission: getFirebaseTokenWithPermission,

    subscribeToTopic: function (topic, success, error) {
        call('subscribeToTopic', [topic], success, error);
    },

    unsubscribeFromTopic: function (topic, success, error) {
        call('unsubscribeFromTopic', [topic], success, error);
    },

    getInitialNotification: noArgs('getInitialNotification'),

    startNotificationListener: function (success, error) {
        call('startNotificationListener', [], function (event) {
            dispatchLocalEvent(event);
            if (success) {
                success(event);
            }
        }, error);
    },

    stopNotificationListener: noArgs('stopNotificationListener'),

    on: function (type, handler) {
        if (!isFunction(handler)) {
            return noop;
        }
        if (!eventHandlers[type]) {
            eventHandlers[type] = [];
        }
        eventHandlers[type].push(handler);
        return function () {
            api.off(type, handler);
        };
    },

    off: function (type, handler) {
        var handlers = eventHandlers[type];
        if (!handlers) {
            return;
        }
        var index = handlers.indexOf(handler);
        if (index >= 0) {
            handlers.splice(index, 1);
        }
    }
};

module.exports = api;