/**
 * Common utility functions.
 */
(function(context,$) {

    "use strict";

    context.JK = context.JK || {};
    var logger = context.JK.logger;

    // types
    var registrationTypes = {
        native : "Native",
        facebook : "Facebook"
    };

    var sessionCreationTypes = {
        create : "Create",
        join : "Join"
    };

    var sessionQualityTypes = {
        good : "Good",
        poor : "Poor"
    };

    var invitationTypes = {
        email : "Email",
        facebook : "Facebook",
        google : "Google"
    };

    var friendConnectTypes = {
        request : "Request",
        accept : "Accept"
    };

    var recordingActions = {
        make : "Make",
        share : "Share"
    };

    var recordingShareTypes = {
        facebook : "Facebook",
        syndicationWidget : "SyndWidget",
        syndicationUrl: "SyndURL"
    };

    var recordingPlayActions = {
        website : "Website",
        client : "Client",
        facebook : "Facebook",
        syndicationWidget : "SyndWidget",
        syndicationUrl: "SyndURL"
    };
    
    var sessionPlayActions = {
        website : "Website",
        client : "Client",
        facebook : "Facebook",
        syndicationWidget : "SyndWidget",
        syndicationUrl: "SyndURL"
    };

    var userLabels = {
        registeredUser : "RegisteredUser",
        visitor: "Visitor"
    };

    var bandActions = {
        create : "Create",
        join : "Join",
        session : "Session",
        recording : "Recording"
    };

    var jkSocialTargets = {
        musician : 'Musician',
        band : 'Band',
        fan : 'Fan',
        recording : 'Recording',
        session : 'Session',
        facebook: 'facebook',
        twitter: 'twitter',
        google: 'google',
    };

    var audioTestFailReasons = {
        latency : 'Latency',
        ioVariance : 'ioVariance',
        ioTarget : 'ioTarget'
    }

    var audioTestDataReasons = {
      pass : 'Pass',
      latencyFail : 'LatencyFail',
      ioVarianceFail : 'ioVarianceFail',
      ioTargetFail : 'ioTargetFail'
    }

    var networkTestFailReasons = {
      stun : 'STUN',
      bandwidth : 'Bandwidth',
      packetRate : 'PacketRate',
      jitter : 'Jitter',
      jamerror : 'ServiceError',
      noNetwork : 'NoNetwork'
    }

    var categories = {
        register : "Register",
        download : "DownloadClient",
        audioTest : "AudioTest",
        audioTestData : 'AudioTestData',
        trackConfig : "AudioTrackConfig",
        networkTest : "NetworkTest",
        sessionCount : "SessionCount",
        sessionMusicians : "SessionMusicians",
        sessionQuality : "SessionQuality",
        invite : "Invite",
        findSession : "FindSession",
        friendConnect : "Connect",
        recording : "Recording",
        recordingPlay : "RecordingPlay",
        sessionPlay : "SessionPlay",
        band : "Band",
        jkLike : 'jkLike',
        jkFollow : 'jkFollow',
        jkFavorite : 'jkFavorite',
        jkComment : 'jkComment'
    };

    function translatePlatformForGA(platform) {
        assertOneOf(platform, context.JK.OS);

        if(platform == context.JK.OS.WIN32) {
            return "Windows";
        }
        if(platform == context.JK.OS.OSX) {
            return "Mac";
        }
        if(platform == context.JK.OS.UNIX) {
            return "Unix";
        }
    }

    function assertBoolean(value) {
        if(typeof value != 'boolean') {
            throw "value is not a boolean: " + JSON.stringify(value);
        }
    }

    function assertNumber(value) {
        if(typeof value != 'number') {
            throw "value is not a number: " + JSON.stringify(value);
        }
    }

    function assertOneOf(enumValue, enums){
        var found = false;
        for (var key in enums) {
            if (enumValue == enums[key]) {
                found = true;
                break;
            }
        }
        if(!found) {
            throw "unable to find enum: " + enumValue + " in: " + JSON.stringify(enums);
        }
    }

    function trackRegister(asMusician, registrationType) {
        assertBoolean(asMusician);
        assertOneOf(registrationType, registrationTypes);

        var action = asMusician ? "Musician" : "Fan";

        context.ga('send', 'event', categories.register, action, registrationType);
    }

    function trackDownload(platform) {
       var normalizedPlatform = translatePlatformForGA(platform);

       context.ga('send', 'event', categories.download, normalizedPlatform);
    }

    function trackFTUECompletion(state, platform) {
        var normalizedPlatform = translatePlatformForGA(platform);

        context.ga('send', 'event', categories.audioTest, state, normalizedPlatform);
    }

    function trackSessionCount(musicianAccess, fanAccess, invitationCount) {
        assertBoolean(musicianAccess);
        assertBoolean(fanAccess);
        assertNumber(invitationCount);

        var gaMusicianAccess = musicianAccess ? "MusicianPublic" : "MusicianPrivate";
        var gaFanAccess = fanAccess ? "FanPublic" : "FanPrivate";

        context.ga('send', 'event', categories.sessionCount, gaMusicianAccess, gaFanAccess, invitationCount);
    }

    function trackSessionMusicians(joinOrCreate) {
        assertOneOf(joinOrCreate, sessionCreationTypes);

        context.ga('send', 'event', categories.sessionMusicians, joinOrCreate);
    }

    function trackSessionQuality(goodOrPoor) {
        assertOneOf(goodOrPoor, sessionQualityTypes);
        context.ga('send', 'event', categories.sessionQuality, goodOrPoor);
    }

    function trackServiceInvitations(invitationType, numInvited) {
        assertOneOf(invitationType, invitationTypes);
        assertNumber(numInvited);

        context.ga('send', 'event', categories.invite, invitationType, numInvited);
    }

    function trackFindSessions(numSessionsFound) {
        assertNumber(numSessionsFound);

        var sessionCountRollup = "n/a";
        if(numSessionsFound === 0) {
            sessionCountRollup = "0";
        }
        else if(numSessionsFound >= 1 && numSessionsFound <= 5) {
            sessionCountRollup = "1-5";
        }
        else if(numSessionsFound >= 6 && numSessionsFound <= 10) {
            sessionCountRollup = "6-10";
        }
        else {
            sessionCountRollup = "10+";
        }

        context.ga('send', 'event', categories.findSession, sessionCountRollup, numSessionsFound);
    }

    // if you want to pass in no title, either omit it from the arg list when u invoke virtualPageView, or pass in undefined, NOT null
    function virtualPageView(page, title) {

        context.ga('send', 'pageview', {
            'page': page,
            'title': title
        });
    }

    function trackFriendConnect(friendConnectType) {
        assertOneOf(friendConnectType, friendConnectTypes);

        context.ga('send', 'event', categories.friendConnect, friendConnectType);
    }

    // when someone keeps a recording
    function trackMakeRecording() {
        context.ga('send', 'event', categories.recording, recordingActions.make);
    }

    // when someone shares a recording
    function trackShareRecording(shareType) {
        assertOneOf(shareType, recordingShareTypes);

        context.ga('send', 'event', categories.recording, recordingActions.share, shareType);
    }

    function _defaultPlayAction() {
        return !window.jamClient || ((typeof(FakeJamClient)!='undefined') && window.jamClient === FakeJamClient) ? 'Website' : 'Client';
    }

    // when someone plays a recording
    function trackRecordingPlay(recordingAction) {
        if (!recordingAction) {
            recordingAction = _defaultPlayAction();
        }
        assertOneOf(recordingAction, recordingPlayActions);
        var label = JK.currentUserId ? userLabels.registeredUser :  userLabels.visitor;

        context.ga('send', 'event', categories.recordingPlay, recordingAction, label);
    }

    // when someone plays a live session broadcast
    function trackSessionPlay(recordingAction) {
        if (!recordingAction) {
            recordingAction = _defaultPlayAction();
        }
        assertOneOf(recordingAction, sessionPlayActions);
        var label = JK.currentUserId ? userLabels.registeredUser :  userLabels.visitor;

        context.ga('send', 'event', categories.sessionPlay, recordingAction, label);
    }

    function trackBand(bandAction) {
        assertOneOf(bandAction, bandActions);

        context.ga('send', 'event', categories.band, bandAction);
    }

    function trackJKSocial(category, target, data) {
        assertOneOf(category, categories);
        assertOneOf(target, jkSocialTargets);

        context.ga('send', 'event', category, target, data);
    }

    function trackNetworkTest(platform, numUsers) {
      var normalizedPlatform = translatePlatformForGA(platform);

      context.ga('send', 'event', categories.networkTest, 'Passed', normalizedPlatform, numUsers);
    }

    function trackNetworkTestFailure(reason, data) {
      assertOneOf(reason, networkTestFailReasons);

      context.ga('send', 'event', categories.networkTest, 'Failed', reason, data);
    }

    function trackAudioTestCompletion(platform) {
      var normalizedPlatform = translatePlatformForGA(platform);

      context.ga('send', 'event', categories.audioTest, 'Passed', normalizedPlatform);
    }

    function trackAudioTestFailure(platform, reason, data) {
      assertOneOf(reason, audioTestFailReasons);

      var normalizedPlatform = translatePlatformForGA(platform);

      if(normalizedPlatform == "Windows") {
        var action = "FailedWin";
      }
      else if(normalizedPlatform == "Mac") {
        var action = "FailedMac";
      }
      else {
        var action = "FailedLinux";
      }

      context.ga('send', 'event', categories.audioTest, action, reason, data);
    }

    function trackConfigureTracksCompletion(platform) {
      var normalizedPlatform = translatePlatformForGA(platform);

      context.ga('send', 'event', categories.trackConfig, 'Passed', normalizedPlatform);
    }

    function trackAudioTestData(uniqueDeviceName, reason, data) {
      assertOneOf(reason, audioTestDataReasons);

      context.ga('send', 'event', categories.audioTestData, uniqueDeviceName, reason, data);
    }

    var GA = {};
    GA.Categories = categories;
    GA.SessionCreationTypes = sessionCreationTypes;
    GA.SessionQualityTypes = sessionQualityTypes;
    GA.InvitationTypes = invitationTypes;
    GA.FriendConnectTypes = friendConnectTypes;
    GA.RecordingActions = recordingActions;
    GA.BandActions = bandActions;
    GA.JKSocialTargets = jkSocialTargets;
    GA.AudioTestFailReasons = audioTestFailReasons;
    GA.AudioTestDataReasons = audioTestDataReasons;
    GA.NetworkTestFailReasons = networkTestFailReasons;
    GA.trackRegister = trackRegister;
    GA.trackDownload = trackDownload;
    GA.trackFTUECompletion = trackFTUECompletion;
    GA.trackNetworkTest = trackNetworkTest;
    GA.trackNetworkTestFailure = trackNetworkTestFailure;
    GA.trackAudioTestCompletion = trackAudioTestCompletion;
    GA.trackAudioTestFailure = trackAudioTestFailure;
    GA.trackAudioTestData = trackAudioTestData;
    GA.trackConfigureTracksCompletion = trackConfigureTracksCompletion;
    GA.trackSessionCount = trackSessionCount;
    GA.trackSessionMusicians = trackSessionMusicians;
    GA.trackSessionQuality = trackSessionQuality;
    GA.trackServiceInvitations = trackServiceInvitations;
    GA.trackFindSessions = trackFindSessions;
    GA.virtualPageView = virtualPageView;
    GA.trackFriendConnect = trackFriendConnect;
    GA.trackMakeRecording = trackMakeRecording;
    GA.trackShareRecording = trackShareRecording;
    GA.trackRecordingPlay = trackRecordingPlay;
    GA.trackSessionPlay = trackSessionPlay;
    GA.trackBand = trackBand;
    GA.trackJKSocial = trackJKSocial;


    context.JK.GA = GA;

})(window,jQuery);