/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
*/

describe("channel", function () {
    var channel = require('cordova/channel'),
        multiChannel,
        stickyChannel;

    function callCount(spy) {
        return spy.argsForCall.length;
    }
    function expectCallCount(spy, count) {
        expect(callCount(spy)).toEqual(count);
    }
    beforeEach(function() {
        multiChannel = channel.create('multiChannel');
        stickyChannel = channel.createSticky('stickyChannel');
    });

    describe("subscribe method", function() {
        it("should throw an exception if no function is provided", function() {
            expect(function() {
                multiChannel.subscribe();
            }).toThrow();

            expect(function() {
                multiChannel.subscribe(null);
            }).toThrow();

            expect(function() {
                multiChannel.subscribe(undefined);
            }).toThrow();

            expect(function() {
                multiChannel.subscribe({apply:function(){},call:function(){}});
            }).toThrow();
        });
        it("should not change number of handlers if no function is provided", function() {
            var initialLength = multiChannel.numHandlers;

            try {
                multiChannel.subscribe();
            } catch(e) {}

            expect(multiChannel.numHandlers).toEqual(initialLength);

            try {
                multiChannel.subscribe(null);
            } catch(e) {}

            expect(multiChannel.numHandlers).toEqual(initialLength);
        });
        it("should not change number of handlers when subscribing same function multiple times", function() {
            var handler = function(){};

            multiChannel.subscribe(handler);
            multiChannel.subscribe(handler);
            stickyChannel.subscribe(handler);
            stickyChannel.subscribe(handler);

            expect(multiChannel.numHandlers).toEqual(1);
            expect(stickyChannel.numHandlers).toEqual(1);
        });
    });

    describe("unsubscribe method", function() {
        it("should throw an exception if passed in null or undefined", function() {
            expect(function() {
                multiChannel.unsubscribe();
            }).toThrow();
            expect(function() {
                multiChannel.unsubscribe(null);
            }).toThrow();
        });
        it("should not decrement numHandlers if unsubscribing something that does not exist", function() {
            multiChannel.subscribe(function() {});
            multiChannel.unsubscribe(function() {});
            expect(multiChannel.numHandlers).toEqual(1);
        });
        it("should change the handlers length appropriately", function() {
            var firstHandler = function() {};
            var secondHandler = function() {};
            var thirdHandler = function() {};

            multiChannel.subscribe(firstHandler);
            multiChannel.subscribe(secondHandler);
            multiChannel.subscribe(thirdHandler);
            expect(multiChannel.numHandlers).toEqual(3);

            multiChannel.unsubscribe(thirdHandler);
            expect(multiChannel.numHandlers).toEqual(2);

            multiChannel.unsubscribe(firstHandler);
            multiChannel.unsubscribe(secondHandler);

            expect(multiChannel.numHandlers).toEqual(0);
        });
        it("should not decrement handlers length more than once if unsubscribing a single handler", function() {
            var firstHandler = function(){};
            multiChannel.subscribe(firstHandler);

            expect(multiChannel.numHandlers).toEqual(1);

            multiChannel.unsubscribe(firstHandler);
            multiChannel.unsubscribe(firstHandler);
            multiChannel.unsubscribe(firstHandler);
            multiChannel.unsubscribe(firstHandler);

            expect(multiChannel.numHandlers).toEqual(0);
        });
        it("should not unregister a function registered with a different handler", function() {
            var cHandler = function(){};
            var c2Handler = function(){};
            var c2 = channel.create('jables');
            multiChannel.subscribe(cHandler);
            c2.subscribe(c2Handler);

            expect(multiChannel.numHandlers).toEqual(1);
            expect(c2.numHandlers).toEqual(1);

            multiChannel.unsubscribe(c2Handler);
            c2.unsubscribe(cHandler);

            expect(multiChannel.numHandlers).toEqual(1);
            expect(c2.numHandlers).toEqual(1);
        });
    });

    function commonFireTests(multi) {
        it("should fire all subscribed handlers", function() {
            var testChannel = multi ? multiChannel : stickyChannel;
            var handler = jasmine.createSpy();
            var anotherOne = jasmine.createSpy();

            testChannel.subscribe(handler);
            testChannel.subscribe(anotherOne);

            testChannel.fire();

            expectCallCount(handler, 1);
            expectCallCount(anotherOne, 1);
        });
        it("should pass params to handlers", function() {
            var testChannel = multi ? multiChannel : stickyChannel;
            var handler = jasmine.createSpy();

            testChannel.subscribe(handler);

            testChannel.fire(1, 2, 3);
            expect(handler.argsForCall[0]).toEqual({0:1, 1:2, 2:3});
        });
        it("should not fire a handler that was unsubscribed", function() {
            var testChannel = multi ? multiChannel : stickyChannel;
            var handler = jasmine.createSpy();
            var anotherOne = jasmine.createSpy();

            testChannel.subscribe(handler);
            testChannel.subscribe(anotherOne);
            testChannel.unsubscribe(handler);

            testChannel.fire();

            expectCallCount(handler, 0);
            expectCallCount(anotherOne, 1);
        });
        it("should not fire a handler more than once if it was subscribed more than once", function() {
            var testChannel = multi ? multiChannel : stickyChannel;
            var handler = jasmine.createSpy();

            testChannel.subscribe(handler);
            testChannel.subscribe(handler);
            testChannel.subscribe(handler);

            testChannel.fire();

            expectCallCount(handler, 1);
        });
        it("handler should be called when subscribed, removed, and subscribed again", function() {
            var testChannel = multi ? multiChannel : stickyChannel;
            var handler = jasmine.createSpy();

            testChannel.subscribe(handler);
            testChannel.unsubscribe(handler);
            testChannel.subscribe(handler);

            testChannel.fire();

            expectCallCount(handler, 1);
        });
        it("should not prevent a callback from firing when it is removed during firing.", function() {
            var testChannel = multi ? multiChannel : stickyChannel;
            var handler = jasmine.createSpy().andCallFake(function() { testChannel.unsubscribe(handler2); });
            var handler2 = jasmine.createSpy();
            testChannel.subscribe(handler);
            testChannel.subscribe(handler2);
            testChannel.fire();
            expectCallCount(handler, 1);
            expectCallCount(handler2, 1);
        });
    }
    describe("fire method for sticky channels", function() {
        commonFireTests(false);
        it("should instantly trigger the callback if the event has already been fired", function () {
            var before = jasmine.createSpy('before'),
                after = jasmine.createSpy('after');

            stickyChannel.subscribe(before);
            stickyChannel.fire(1, 2, 3);
            stickyChannel.subscribe(after);

            expectCallCount(before, 1);
            expectCallCount(after, 1);
            expect(after.argsForCall[0]).toEqual({0:1, 1:2, 2:3});
        });
        it("should instantly trigger the callback if the event is currently being fired.", function () {
            var handler1 = jasmine.createSpy().andCallFake(function() { stickyChannel.subscribe(handler2); }),
                handler2 = jasmine.createSpy().andCallFake(function(arg1) { expect(arg1).toEqual('foo');});

            stickyChannel.subscribe(handler1);
            stickyChannel.fire('foo');

            expectCallCount(handler2, 1);
        });
        it("should unregister all handlers after being fired.", function() {
            var handler = jasmine.createSpy();
            stickyChannel.subscribe(handler);
            stickyChannel.fire();
            stickyChannel.fire();
            expectCallCount(handler, 1);
        });
    });
    describe("fire method for multi channels", function() {
        commonFireTests(true);
        it("should not trigger the callback if the event has already been fired", function () {
            var before = jasmine.createSpy('before'),
                after = jasmine.createSpy('after');

            multiChannel.subscribe(before);
            multiChannel.fire();
            multiChannel.subscribe(after);

            expectCallCount(before, 1);
            expectCallCount(after, 0);
        });
        it("should not trigger the callback if the event is currently being fired.", function () {
            var handler1 = jasmine.createSpy().andCallFake(function() { multiChannel.subscribe(handler2); }),
                handler2 = jasmine.createSpy();

            multiChannel.subscribe(handler1);
            multiChannel.fire();
            multiChannel.fire();

            expectCallCount(handler1, 2);
            expectCallCount(handler2, 1);
        });
        it("should not unregister handlers after being fired.", function() {
            var handler = jasmine.createSpy();
            multiChannel.subscribe(handler);
            multiChannel.fire();
            multiChannel.fire();
            expectCallCount(handler, 2);
        });
    });
    describe("channel.join()", function() {
        it("should be called when all functions start unfired", function() {
            var handler = jasmine.createSpy(),
                stickyChannel2 = channel.createSticky('stickyChannel');
            channel.join(handler, [stickyChannel, stickyChannel2]);
            expectCallCount(handler, 0);
            stickyChannel.fire();
            expectCallCount(handler, 0);
            stickyChannel2.fire();
            expectCallCount(handler, 1);
        });
        it("should be called when one functions start fired", function() {
            var handler = jasmine.createSpy(),
                stickyChannel2 = channel.createSticky('stickyChannel');
            stickyChannel.fire();
            channel.join(handler, [stickyChannel, stickyChannel2]);
            expectCallCount(handler, 0);
            stickyChannel2.fire();
            expectCallCount(handler, 1);
        });
        it("should be called when all functions start fired", function() {
            var handler = jasmine.createSpy(),
                stickyChannel2 = channel.createSticky('stickyChannel');
            stickyChannel.fire();
            stickyChannel2.fire();
            channel.join(handler, [stickyChannel, stickyChannel2]);
            expectCallCount(handler, 1);
        });
        it("should throw if a channel is not sticky", function() {
            expect(function() {
                channel.join(function(){}, [stickyChannel, multiChannel]);
            }).toThrow();
        });
    });
    describe("onHasSubscribersChange", function() {
        it("should be called only when the first subscriber is added and last subscriber is removed.", function() {
            var handler = jasmine.createSpy().andCallFake(function() {
                if (callCount(handler) == 1) {
                    expect(this.numHandlers).toEqual(1);
                } else {
                    expect(this.numHandlers).toEqual(0);
                }
            });
            multiChannel.onHasSubscribersChange = handler;
            function foo1() {}
            function foo2() {}
            multiChannel.subscribe(foo1);
            multiChannel.subscribe(foo2);
            multiChannel.unsubscribe(foo1);
            multiChannel.unsubscribe(foo2);
            expectCallCount(handler, 2);
        });
    });
});