(function(context,$) {

    "use strict";

    context.JK = context.JK || {};
    context.JK.FakeJamClient = function(app, p2pMessageFactory) {
        var ChannelGroupIds = context.JK.ChannelGroupIds
        var logger = context.JK.logger;
        logger.info("*** Fake JamClient instance initialized. ***");

        // Change this to false if you want to see FTUE with fake jam client
        var ftueStatus = true;
        var eventCallbackName = '';
        var alertCallbackName = '';
        var eventCallbackRate = 1000;
        var vuValue = -70;
        var vuChange = 10;
        var callbackTimer = null;
        var _mix = -30;
        var device_id = -1;
        var latencyCallback = null;
        var frameSize = 2.5;
        var fakeJamClientRecordings = null;
        var p2pCallbacks = null;
        var videoShared = false;
        var metronomeActive=false;
        var metronomeBPM=false;
        var metronomeSound=false;
        var metronomeMeter=0;
        var backingTrackPath = "";
        var backingTrackLoop = false;
        var simulateNoInputs = false;

        function dbg(msg) { logger.debug('FakeJamClient: ' + msg); }

        // Bummer that javascript doesn't have much in the way of reflection.
        // arguments.callee.name would probably do what we want, but it's deprecated
        // and not allowed when using "strict"
        // (Wishing I could write a single function which debug logs the name of the
        // current function and a JSON stringify of the arguments).

        function OpenSystemBrowser(href) {
            dbg("OpenSystemBrowser('" + href + "')");
            context.window.open(href);
        }
        
        function RestartApplication() {}
        function ShutdownApplication() {}
        function FTUEPageEnter() {}
        function FTUEPageLeave() {}
        function FTUECancel() {}
        function FTUEGetMusicProfileName() {

          if(simulateNoInputs) {
            return "System Default (Playback Only)"
          }
          else {
            return "FTUEAttempt-1"
          }
        }
        function FTUESetMusicProfileName() {

        }

        function FTUESetPreferredMixerSampleRate() {}
        function FTUESetPreferredOutputSampleRate(){ }
        function FTUESetPreferredChatSampleRate() {}
        function FTUEgetInputDeviceSampleRate() {
          return 44100;
        }
        function FTUEgetOutputDeviceSampleRate() {
          return 44100;
        }

        
        function FTUESelectVideoCaptureDevice(device, settings) {

        }
        function FTUESetVideoEncodeResolution(resolution) {

        }   
        function FTUEGetVideoCaptureDeviceNames() {
            return ["Built-in Webcam HD"]
        }
        function FTUECurrentSelectedVideoDevice() {
            return {"xy323ss": "Built-in Webcam HD"}
        }
        function FTUEGetAvailableEncodeVideoResolutions() {
            return {
                1: "1024x768",
                2: "800x600"
            }
        }

        function FTUEGetVideoCaptureDeviceCapabilities() {
            return {}
        }

        function isSessVideoShared() {
            return videoShared;
        }

        function SessStopVideoSharing() {
            videoShared=false;
        }
      
        function SessStartVideoSharing(bitrate) {
            if (!bitrate || typeof(bitrate)=="undefined") {
                bitrate = 0
            }
            videoShared=true;   
        }

        function FTUEGetInputLatency() {
            dbg("FTUEGetInputLatency");
            return 2;
        }
        function FTUESetInputLatency(latency) {
            dbg("FTUESetInputLatency:" + latency);
        }
        function FTUEGetOutputLatency() {
            dbg("FTUEGetOutputLatency");
            return 2;
        }
        function FTUESetOutputLatency(latency) {
            dbg("FTUESetOutputLatency:" + latency);
        }
        function FTUEGetVolumeRanges () {
            dbg("FTUEGetVolumeRanges");
            return {
                input_maximum: 20,
                input_minimum: -80,
                output_maximum: 20,
                output_minimum: -80
            };
        }
        function FTUEHasControlPanel() {
            dbg("FTUEHasControlPanel");
            return true;
        }
        function FTUEGetFrameSize(newSize) {
            dbg("FTUEGetFrameSize");
            return frameSize;
        }
        function FTUESetFrameSize(newSize) {
            dbg("FTUESetFrameSize:" + newSize);
            // one of 2.5, 5 or 10
            frameSize = newSize;
        }
        function FTUEOpenControlPanel() {
            dbg("FTUEOpenControlPanel");
            context.alert("Simulated ASIO Dialog");
        }
        function FTUEInit() { dbg("FTUEInit"); }
        function FTUERefreshDevices() { dbg("FTUERefreshDevices()"); }
        function FTUESave(b) { dbg("FTUESave(" + b + ")"); return {}; }
        function FTUEGetStatus() { return ftueStatus; }
        function FTUESetStatus(b) { ftueStatus = b; }
        function FTUESetMusicDevice(id) { dbg("FTUESetMusicDevice"); }
        function FTUEGetAudioDevices() {
          return {"devices":[{"display_name":"Built-in","guid":"Built-in","input_count":1,"name":"Built-in","output_count":1,"port_audio_name":"Built-in"},{"display_name":"JamKazam Virtual Monitor","guid":"JamKazam Virtual Monitor","input_count":0,"name":"JamKazam Virtual Monitor","output_count":1,"port_audio_name":"JamKazam Virtual Monitor"}]}
        }
        function FTUEGetDevices() {
            dbg('FTUEGetMusicDevices');
            return {
                "ASIO4ALL v2":"ASIO4ALL v2 - ASIO",
                "M-Audio FW ASIO":"M-AUDIO FW ASIO - ASIO"
            };
        }
        function FTUEGetMusicInputs() {
            dbg('FTUEGetMusicInputs');
            return {
                "i~11~MultiChannel (FWAPMulti)~0^i~11~Multichannel (FWAPMulti)~1":
                    "Multichannel (FWAPMulti) - Channel 1/Multichannel (FWAPMulti) - Channel 2"
            };
        }
        function FTUEGetMusicOutputs() {
            dbg('FTUEGetMusicOutputs');
            return {
                "o~11~Multichannel (FWAPMulti)~0^o~11~Multichannel (FWAPMulti)~1":
                    "Multichannel (FWAPMulti) - Channel 1/Multichannel (FWAPMulti) - Channel 2"
            };
        }
        function FTUEGetChatInputs() {
            dbg('FTUEGetChatInputs');
            return {
                "i~11~MultiChannel (FWAPMulti)~0^i~11~Multichannel (FWAPMulti)~1":
                    "Multichannel (FWAPMulti) - Channel 1/Multichannel (FWAPMulti) - Channel 2"
            };
        }
        function FTUEGetChannels() {
          return {
            "inputs": [
            {
              "assignment": 1,
              "chat": false,
              "device_id": "Built-in Microph",
              "device_type": 5,
              "id": "i~5~Built-in Microph~0~0~Built-in",
              "name": "Built-in Microph - Left",
              "number": 0
            },
            {
              "assignment": 0,
              "chat": false,
              "device_id": "Built-in Microph",
              "device_type": 5,
              "id": "i~5~Built-in Microph~1~0~Built-in",
              "name": "Built-in Microph - Right",
              "number": 1
            }
          ],
            "outputs": [
            {
              "assignment": -1,
              "chat": false,
              "device_id": "Built-in Output",
              "device_type": 5,
              "id": "o~5~Built-in Output~0~0~Built-in",
              "name": "Built-in Output - Left",
              "number": 0
            },
            {
              "assignment": -1,
              "chat": false,
              "device_id": "Built-in Output",
              "device_type": 5,
              "id": "o~5~Built-in Output~1~0~Built-in",
              "name": "Built-in Output - Right",
              "number": 1
            }
          ]
          };
        }

        function FTUEClearChannelAssignments(){}
        function FTUEClearChatInput(){}
        function FTUEGetAudioDevices() {
          return {
            "devices": [
            {
              "display_name": "Built-in",
              "guid": "Built-in",
              "input_count": 1,
              "name": "Built-in",
              "output_count": 1,
              "port_audio_name": "Built-in"
            },
            {
              "display_name": "JamKazam Virtual Monitor",
              "guid": "JamKazam Virtual Monitor",
              "input_count": 0,
              "name": "JamKazam Virtual Monitor",
              "output_count": 1,
              "port_audio_name": "JamKazam Virtual Monitor"
            }
          ]
          };
        }
        function FTUEStartIoPerfTest() {}
        function FTUEGetIoPerfData() {
          return {
            "in_var" : 0.15,
            "out_var" : 0.25,
            "in_median" : 399.9,
            "out_median" : 400.3,
            "in_target" : 400,
            "out_target" : 400
          };
        }
        function FTUESetInputMusicDevice() { }
        function FTUESetOutputMusicDevice() { }
        function FTUEGetInputMusicDevice() { return 'Built-in'; }
        function FTUEGetOutputMusicDevice() { return 'Built-in'; }

        function FTUESetMusicInput() { dbg('FTUESetMusicInput'); }
        function FTUESetChatInput() { dbg('FTUESetChatInput'); }
        function FTUESetMusicOutput() { dbg('FTUESetMusicOutput'); }
        function FTUEGetInputVolume() { dbg('FTUEGetInputVolume'); return -60; }
        function FTUESetInputVolume() { dbg('FTUESetInputVolume'); }
        function FTUEGetOutputVolume() { dbg('FTUEGetOutputVolume'); return -40; }
        function FTUESetOutputVolume() { dbg('FTUESetOutputVolume'); }
        function FTUEGetChatInputVolume() { dbg('FTUEGetChatInputVolume'); return -10; }
        function FTUESetChatInputVolume() { dbg('FTUESetChatInputVolume'); }
        function FTUERegisterVUCallbacks() {
            dbg('FTUERegisterVUCallbacks');
        }
        function FTUERegisterLatencyCallback(functionName) {
            dbg('FTUERegisterLatencyCallback');
            latencyCallback = functionName;
        }
        function FTUEStartLatency() {
            function cb() {
                // Change 4192 to modify latency MS results (in microseconds)
                eval(latencyCallback + "(10.0)");
            }
            context.setTimeout(cb, 1000);
        }

        function FTUEGetExpectedLatency() {
            return {latencyknown:true, latency:5}
        }

        function FTUEGetGoodConfigurationList() {
          return ['default'];
        }

        function FTUEGetAllAudioConfigurations() {
            return ['default'];
        }

        function FTUEGetGoodAudioConfigurations() {
            return ['default'];
        }

        function FTUEGetConfigurationDevice() {
            return 'Good Device';
        }

        function FTUELoadAudioConfiguration() {
          return true;
        }

        function FTUEIsMusicDeviceWDM() {
            return false;
        }

        function FTUECreateUpdatePlayBackProfile() {
          return true;
        }

        function RegisterVolChangeCallBack(functionName) {
            dbg('RegisterVolChangeCallBack');
        }


        function GetOS() { return 100000000; }
        function GetOSAsString() {
            return "Win32";
            //return "MacOSX";
        }

        function LatencyUpdated(map) { dbg('LatencyUpdated:' + JSON.stringify(map)); }
        function LeaveSession(map) { dbg('LeaveSession:' + JSON.stringify(map)); }

        // this is not a real bridge method; purely used by the fake jam client
        function RegisterP2PMessageCallbacks(callbacks) {
                p2pCallbacks = callbacks;
        }

        function P2PMessageReceived(from, payload) {

            dbg('P2PMessageReceived');
            // this function is different in that the payload is a JSON ready string;
            // whereas a real p2p message is base64 encoded binary packaged data

            try {
                payload = JSON.parse(payload);
            }
            catch(e) {
                logger.warn("unable to parse payload as JSON from client %o, %o, %o", from, e, payload);
            }

            var callback = p2pCallbacks[payload.type];
            if(callback) {
                callback(from, payload);
            }
        }

        function JoinSession(sessionId) {dbg('JoinSession:' + sessionId);}
        function ParticipantLeft(session, participant) {
            dbg('ParticipantLeft:' + JSON.stringify(session) + ',' +
                JSON.stringify(participant));
        }
        function ParticipantJoined(session, participant) {
            dbg('ParticipantJoined:' + JSON.stringify(session) + ',' +
                JSON.stringify(participant));
        }
        function RecordTestBegin() { dbg('RecordTestBegin'); }
        function RecordTestEnd() { dbg('RecordTestBegin'); }
        function RecordTestPlayback() { dbg('RecordTestBegin'); }
        function SendP2PMessage(s1,s2) { dbg('SendP2PMessage:' + s1 + ',' + s2); }
        function SetASIOEnabled(i1, i2, i3, i4, i5, i6) {
            dbg('SetASIOEnabled(' + i1 + ',' + i2 + ',' + i3 + ',' + i4 + ',' + i5 + ',' + i6 + ')');
        }
        function SignalLatencyUpdated(client) {
            dbg('SignalLatencyUpdated:' + JSON.stringify(client));
        }
        function SignalSendP2PMessage(s1,ba) {
            dbg('SignalSendP2PMessage:' + JSON.stringify(arguments));
        }
        function StartPlayTest(s) { dbg('StartPlayTest' + JSON.stringify(arguments)); }
        function StartRecordTest(s) { dbg('StartRecordTest' + JSON.stringify(arguments)); }
        function StartRecording(recordingId, groupedClientTracks) {
            dbg('StartRecording');
            fakeJamClientRecordings.StartRecording(recordingId, groupedClientTracks);
        }
        function StopPlayTest() { dbg('StopPlayTest'); }
        function StopRecording(recordingId, groupedTracks, errorReason, detail) {
            dbg('StopRecording');
            fakeJamClientRecordings.StopRecording(recordingId, groupedTracks, errorReason, detail);
        }

        function AbortRecording(recordingId, errorReason, errorDetail) {
            dbg('AbortRecording');
            fakeJamClientRecordings.AbortRecording(recordingId, errorReason, errorDetail);
        }
        function OnTrySyncCommand(cmd) {

        }
        function GetRecordingManagerState() {
          return {running: false}
        }

        function TestASIOLatency(s) { dbg('TestASIOLatency' + JSON.stringify(arguments)); }

        function TestLatency(clientID, callbackFunctionName, timeoutCallbackName) {
            logger.debug("Fake JamClient: TestLatency called with client, " + clientID + " and callback function name: " + callbackFunctionName);
            var response = {
                clientID: clientID,
                latency: 50
            };
            var js = callbackFunctionName + "(" + JSON.stringify(response) + ");";
            eval(js);
        }

        function IsMyNetworkWireless() {
          // 1=true, 0 = false, -1=unknown
          return 1;
        }

        function SetNetworkTestScore(numClients) {

        }

        function GetNetworkTestScore() {
          return 8;
        }

        function SetLatencyTestBlocked(blocked) {

        }

        function isLatencyTestBlocked() {
          return false;
        }

        function GetLastLatencyTestTimes() {
          return { initiated: 10000, requested: 10000}
        }

        function GetASIODevices() {
            var response =[{"device_id":0,"device_name":"Realtek High Definition Audio","device_type": 0,"interfaces":[{"interface_id":0,"interface_name":"Realtek HDA SPDIF Out","pins":[{"is_input":false,"pin_id":0,"pin_name":"PC Speaker"}]},{"interface_id":1,"interface_name":"Realtek HD Audio rear output","pins":[{"is_input":false,"pin_id":0,"pin_name":"PC Speaker"}]},{"interface_id":2,"interface_name":"Realtek HD Audio Mic input","pins":[{"is_input":true,"pin_id":0,"pin_name":"Recording Control"}]},{"interface_id":3,"interface_name":"Realtek HD Audio Line input","pins":[{"is_input":true,"pin_id":0,"pin_name":"Recording Control"}]},{"interface_id":4,"interface_name":"Realtek HD Digital input","pins":[{"is_input":true,"pin_id":0,"pin_name":"Capture"}]},{"interface_id":5,"interface_name":"Realtek HD Audio Stereo input","pins":[{"is_input":true,"pin_id":0,"pin_name":"Recording Control"}]}],"wavert_supported":false},{"device_id":1,"device_name":"M-Audio FW Audiophile","device_type": 1,"interfaces":[{"interface_id":0,"interface_name":"FWAPMulti","pins":[{"is_input":false,"pin_id":0,"pin_name":"Output"},{"is_input":true,"pin_id":1,"pin_name":"Input"}]},{"interface_id":1,"interface_name":"FW AP 1/2","pins":[{"is_input":false,"pin_id":0,"pin_name":"Output"},{"is_input":true,"pin_id":1,"pin_name":"Input"}]},{"interface_id":2,"interface_name":"FW AP SPDIF","pins":[{"is_input":false,"pin_id":0,"pin_name":"Output"},{"is_input":true,"pin_id":1,"pin_name":"Input"}]},{"interface_id":3,"interface_name":"FW AP 3/4","pins":[{"is_input":false,"pin_id":0,"pin_name":"Output"}]}],"wavert_supported":false},{"device_id":2,"device_name":"Virtual Audio Cable","device_type": 2,"interfaces":[{"interface_id":0,"interface_name":"Virtual Cable 2","pins":[{"is_input":true,"pin_id":0,"pin_name":"Capture"},{"is_input":false,"pin_id":1,"pin_name":"Output"}]},{"interface_id":1,"interface_name":"Virtual Cable 1","pins":[{"is_input":true,"pin_id":0,"pin_name":"Capture"},{"is_input":false,"pin_id":1,"pin_name":"Output"}]}],"wavert_supported":false},{"device_id":3,"device_name":"WebCamDV WDM Audio Capture","device_type": 3,"interfaces":[{"interface_id":0,"interface_name":"WebCamDV Audio","pins":[{"is_input":true,"pin_id":0,"pin_name":"Recording Control"},{"is_input":false,"pin_id":1,"pin_name":"Volume Control"}]}],"wavert_supported":false}];
            return response;
        }

        // Session Functions

        function SessionCurrrentJamTrackPlayPosMs() {
          return 0;
        }

        function SessionGetJamTracksPlayDurationMs() {
          return 60000;
        }
        function SessionAddTrack() {}

        function SessionAudioResync() {
            logger.debug("Fake JamClient: SessionAudioResync()");
        }

        function SessionGetAllControlState(isMasterOrPersonal) {
            var mixerIds = SessionGetIDs()
            return SessionGetControlState(mixerIds, isMasterOrPersonal);
        }
        function SessionGetControlState(mixerIds, isMasterOrPersonal) {
            dbg("SessionGetControlState");
            var groups =
              [ChannelGroupIds.MasterGroup,
              ChannelGroupIds.MonitorGroup,
              ChannelGroupIds.AudioInputMusicGroup,
              ChannelGroupIds.AudioInputChatGroup,
              ChannelGroupIds.AudioInputChatGroup,
              ChannelGroupIds.UserMusicInputGroup,
              ChannelGroupIds.UserChatInputGroup,
              ChannelGroupIds.PeerMediaTrackGroup,
              ChannelGroupIds.JamTrackGroup,
              ChannelGroupIds.MetronomeGroup];
            var names = [
                "FWAPMulti",
                "FWAPMulti",
                "FWAPMulti",
                "FWAPMulti",
                "",
                "",
                "",
                "",
                "",
                ""                
            ];

            var media_types = [
                "Master",
                "Monitor",
                "AudioInputMusic",
                "AudioInputChat",
                "StreamOutMusic",
                "UserMusicInput",
                "PeerAudioInputMusic",
                "PeerMediaTrack",
                "JamTrack",
                "MetronomeTrack"
            ]
            var clientIds = [
                "",
                "",
                "",
                "",
                "3933ebec-913b-43ab-a4d3-f21dc5f8955b",
                "",
                "",
                "",
                "",
                ""
            ];
            var response = [];
            for (var i=0; i<mixerIds.length; i++) {

                // for testing no inputs, set simulateNoInputs = true
                if(simulateNoInputs && i == 2) continue;

                response.push({
                    client_id: clientIds[i],
                    group_id: groups[i],
                    id: mixerIds[i] + (isMasterOrPersonal ? 'm' : 'p'),
                    master: isMasterOrPersonal,
                    media_type: media_types[i],
                    monitor: !isMasterOrPersonal,
                    mute: false,
                    name: names[i],
                    range_high: 20,
                    range_low: -80,
                    record: true,
                    stereo: true,
                    volume_left: -40,
                    volume_right:-40,
                    pan: 0,
                    instrument_id:50, // see globals.js
                    mode: isMasterOrPersonal,
                    rid: mixerIds[i]
                });
            }
            return response;
        }
        function SessionGetIDs() {
            return [
                "FWAPMulti_0_10000",
                "FWAPMulti_1_10100",
                "FWAPMulti_2_10200",
                "FWAPMulti_3_10500",
                "User@208.191.152.98#",
                "User@208.191.152.98_*"
            ];
        }

        function RegisterRecordingManagerCallbacks(commandStart, commandProgress, commandStop, commandsChanged) {

        }

        function RegisterRecordingCallbacks(startRecordingCallbackName, stopRecordingCallbackName, startedRecordingCallbackName, stoppedRecordingCallbackName, abortedRecordingCallbackName) {
            fakeJamClientRecordings.RegisterRecordingCallbacks(startRecordingCallbackName, stopRecordingCallbackName, startedRecordingCallbackName,stoppedRecordingCallbackName, abortedRecordingCallbackName);
        }

        function SessionRegisterCallback(callbackName) {
            eventCallbackName = callbackName;
            if (callbackTimer) { context.clearInterval(callbackTimer); }
            if (eventCallbackName) {
                callbackTimer = context.setInterval(doCallbacks, eventCallbackRate);
            }
        }

        function SessionSetAlertCallback(callback) {
            alertCallbackName = callback;

            // simulate a backend alert
            /**setTimeout(function() {
              eval(alertCallbackName + '(27)');
            }, 3000)*/
        }

        function SessionSetConnectionStatusRefreshRate(milliseconds) {
            dbg('SessionSetConnectionStatusRefreshRate: ' + milliseconds);
        }

        function SessionSetControlState(stringValue, isMasterOrPersonal) {
            dbg('SessionSetControlState: ' + stringValue + " m/p=" + isMasterOrPersonal);
        }
        function SessionSetRecordingFilename(filename) {}
        function SessionSetRecordingFolder(folderName) {}
        function SessionStartPlay() {}
        function SessionStartRecording() {}
        function SessionStopPlay() {}
        function SessionStopRecording() {}
        function SessionAddPlayTrack() {return true;}
        function SessionRemoveAllPlayTracks(){}
        function isSessionTrackPlaying() { return false; }
        function SessionCurrrentPlayPosMs() { return 0; }
        function SessionGetTracksPlayDurationMs() { return 0; }
        function SessionGetDeviceLatency() { return 10.0; }
        function SessionPageEnter() {logger.debug("FakeJamClient: SessionPageEnter"); return {}}
        function SessionPageLeave() {logger.debug("FakeJamClient: SessionPageLeave")}
        function SetMixerMode(mode) {}
        function SessionGetMasterLocalMix() {
            logger.debug('SessionGetMasterLocalMix. Returning: ' + _mix);
            return _mix;
        }
        function SessionSetMasterLocalMix(level) {
            logger.debug('SessionSetMasterLocalMix(' + level + ')');
            _mix = level;
        }
        function SessionSetUserName(client_id,name){

        }

        function doCallbacks() {
            var names = ["vu"];
            //var ids = ["FWAPMulti_2_10200", "FWAPMulti_0_10000"];
            var ids= ["i~11~MultiChannel (FWAPMulti)~0^i~11~Multichannel (FWAPMulti)~1",
                      "i~11~MultiChannel (FWAPMulti)~0^i~11~Multichannel (FWAPMulti)~2"];

            var args = [];
            for (var i=0; i<ids.length; i++) {
                for (var j=0; j<names.length; j++) {
                    args.push('"' + names[j] + '"');
                    args.push('"' + ids[i] + '"');
                    args.push(vuValue);
                }
            }
            var js = eventCallbackName + '(' + args.join(',') + ')';
            //eval(js);

            vuValue += vuChange;
            if (vuValue > 10 || vuValue < -70) { vuChange = vuChange * -1; }

        }
        function SetVURefreshRate(rateMS) {
            eventCallbackRate = rateMS;
            if (callbackTimer) { context.clearInterval(callbackTimer); }
            if (eventCallbackName) {
                callbackTimer = context.setInterval(doCallbacks, eventCallbackRate);
            }
        }

        // Track Functions


        // Returns a list of objects representing all available audio devices and
        // pins on the current system. On my windows box, I get 38 objects back.
        // First couple examples included here. Note that the list tends to come
        // back with all of the left inputs, then all the right inputs, then all
        // the left outputs, then all the right outputs.
        function TrackGetChannels() {
            // Real example:
            /*
{
    device_id: "1394\\M-Audio&FW_Audiophile",
    full_id: "i~1~\\\\?\\1394#m-audio&fw_audiophile#d4eb0700036c0d00#{6994ad04-93ef-11d0-a3cc-00a0c9223196}\\fwap_12",
    id: "\\\\?\\1394#m-audio&fw_audiophile#d4eb0700036c0d00#{6994ad04-93ef-11d0-a3cc-00a0c9223196}\\fwap_12",
    input: true,
    left: true,
    name: "M-Audio FW Audiophile: FW AP 1/2 - Left"
},
            */

            // But we'll just build a list of names and fake it
            var devices = [
                "M-Audio FW Audiophile: FW AP 1/2"
                //"M-Audio FW Audiophile: FW Multi 1/2",
                //"M-Audio FW Audiophile: FW SPDIF 1/2",
                //"Realtek High Definition Audio: Realtek HD Digital",
                // "Realtek High Definition Audio: Realtek HD Line",
                // "Realtek High Definition Audio: Realtek HD Audio Mic",
                // "Realtek High Definition Audio: Realtek HD Audio Stereo",
                //"WebCamDV WDM Audio Capture: WebCamDV Audio"
            ];
            var suffixes = [ " - Left", " - Right", " - Left", " - Right"];
            var lefts = [true, false, true, false];
            var inputs = [true, true, false, false];
            var types = ["music", "non-music", "music", "non-music"];
            var response = [];
            var name, o, i, j;
            for (j=0; j<4; j++) {
                for (i=0; i<devices.length; i++) {
                    name = devices[i] + suffixes[j];
                    o = {
                        device_id: name,
                        full_id: name,
                        id: name,
                        input: inputs[j],
                        left: lefts[j],
                        name: name,
                        device_type: types[j]
                    };
                    response.push(o);
                }
            }
            return response;
        }

        function TrackGetCount() {
            return 1; // Real version returns whatever was set
        }

        function TrackGetInstrument(trackNumber) {
            if (trackNumber === 1) {
                return 100;
            }
            else {
                return 200;
            }
        }

        function TrackGetChatEnable() {
            return true;
        }

        function TrackSetChatEnable(chat) {

        }

        function TrackSaveAssignments() {}

        function TrackGetDevices() {
            var response = {"Built-in":"Built-in", "ASIO4ALL v2":"ASIO4ALL v2 - ASIO", "BEHRINGER USB AUDIO":"BEHRINGER USB AUDIO - ASIO", "{2B7D1F21-FA6E-11D4-0002-DDCA793267F2}":"SoundMAX HD Audio O - WDM", "{ABCC5A6C-C263-463B-A72F-A5BF64C86EBA}":"Generic USB Audio Device - WDM"};
            return response;
        }

        function TrackDeleteProfile(id) {

        }


        function TrackGetMusicDeviceID() {
            return device_id;
        }

        function TrackSetMusicDevice(id) {
            device_id = id;
        }

        function TrackGetMusicDeviceNames(input) {
            var names = [];
            names.push("Built-in");
            return names;
        }

        // mock response of this method by allowing only even device IDs to open control panel
        function TrackHasControlPanel() {
            return true;
        }

        function TrackIsMusicDeviceType(type) {
            return true;
        }

        function TrackGetChatUsesMusic() {
            return 0;
        }

        function TrackSetChatUsesMusic(usesMusic) {
        }

        function TrackOpenControlPanel() {
            return;
        }

        function TrackLoadAssignments() {}

        function TrackSave() {}

        // Set a Track Assignment.
        // assignment is an enum:
        // CHAT = -2, OUTPUT = -1, UNASSIGNED = 0
        function TrackSetAssignment(chanId, isInput, assignment) {}

        // Get a Track Assignment.
        function TrackGetAssignment(chanId, isInput) {
            // CHAT = -2, OUTPUT = -1, UNASSIGNED = 0
            return 0;
        }

        function TrackSetCount(count) {}

        function TrackSetInstrument(track, instrumentId) {}

        function JamTrackStopPlay() {}
        function JamTrackPlay(){return true;    }
        function JamTrackIsPlayable() {
            return true;
        }
        function JamTrackGetTrackDetail() {
            return {key_state: 'unknown'}
        }
        function JamTrackKeysRequest() {}
        function JamTrackDownload() {}
        // Method which sets volume
        function UpdateMixer(mixerId) {}

        // scoring knobs
        function GetScoreWorkTimingInterval() { return {interval: 1000, backoff:60000} }
        function SetScoreWorkTimingInterval(knobs) {return true;}

        function SessionOpenBackingTrackFile(path, loop) {
            backingTrackPath = path
            backingTrackLoop = loop
        }

        function SessionSetBackingTrackFileLoop(path, loop) {
            backingTrackPath = path
            backingTrackLoop = loop            
        }

        function SessionCloseBackingTrackFile(path) {
            backingTrackPath=""
        }

        function SessionOpenMetronome(bpm, click, meter, mode){
            logger.debug("Setting metronome BPM: ", bpm)
            metronomeActive =true
            metronomeBPM = bpm
            metronomeSound = click
            metronomeMeter = meter
        }
        
        //change setting - click. Mode 0: = mono, 1, = left ear, 2= right ear
        function SessionSetMetronome(bpm,click,meter, mode){
            SessionOpenMetronome(bpm, click, meter, mode)
        }

        //close everywhere
        function SessionCloseMetronome(){
            metronomeActive=false
        }

        function setMetronomeOpenCallback(callback) {

        }

        function getMyNetworkState() {
            return {
                ntp_stable: Math.random() > 0.5
            }
        }

        function getPeerState(clientId) {
            return {
                ntp_stable: Math.random() > 0.5
            }
        }


        // stun
        function NetworkTestResult() { return {remote_udp_blocked: false} }

        // Client Update Functions
        function IsAppInWritableVolume() { return true; }
        function ClientUpdateVersion() { return "Compiled 1.2.3";  }
        function ClientUpdateStartDownload(url, progressCallback, successCallback, failureCallback) {

            // simulate a bunch of download callbacks
            var count = 0;
            var max = 100;
            var bytesReceived = 0;
            var bytesTotal = 10000;

            function fire() {
                count++;
                context.setTimeout(function() {
                    bytesReceived = ( count / max ) * bytesTotal;
                    context.JK.ClientUpdate.DownloadProgressCallback(bytesReceived, bytesTotal, 0, 0);

                    if(count < max) {
                        fire();
                    }
                    else {
                        context.JK.ClientUpdate.DownloadFailureCallback("/some/path/here");
                    }
                }, 50);
            }
            fire();

        }

        function getBackingTrackList() {
            return {backing_tracks: [
              {name:"This is a really long name for a song dude.mp3", size:4283},
              {name:"foo.mp3",size:325783838}
            ]};
        }

        function ClientUpdateStartUpdate(path, successCallback, failureCallback) {}

        // -------------------------------
        // fake jam client methods
        // not a part of the actual bridge
        // -------------------------------
        function SetFakeRecordingImpl(fakeRecordingsImpl) {
            fakeJamClientRecordings = fakeRecordingsImpl;
        }

        function TestNetworkPktBwRate(targetClientId, successCallback, timeoutCallback, testType, duration, numClients, payloadSize) {
          var progress = {progress:true,
                          upthroughput:.95,
                          downthroughput:.95,
                          upjitter: 2.3,
                          downjitter: 2.3
          }
          var count = 0;
          var interval = setInterval(function() {

            eval(successCallback + "(" + JSON.stringify(progress) + ");");

            if(progress.upthroughput < 1) {
              progress.upthroughput += .05;
            }
            if(progress.downthroughput < 1) {
              progress.downthroughput += .05;
            }

            count++;
            if(count == duration) {
              clearInterval(interval);

              delete progress['progress']
              progress.pass = true;
              eval(successCallback + "(" + JSON.stringify(progress) + ");");
            }
          }, 1000);
        }
        function StopNetworkTest(targetClientId) {}
        function OnLoggedIn(userId, sessionToken) {}
        function OnLoggedOut() {}
        function UserAttention(option) {}
        function IsFrontendVisible() {return true;}
        function LastUsedProfileName() {return 'default'};
        function SetLastUsedProfileName(name) {return true;};
        function log(level, message) {
          console.log("beep : " + message)
        }

        function getOperatingMode() {
          if (location.pathname == '/latency_tester') {
            return 'server';
          }
          else {
            return 'client';
          }
        }

        // passed an array of recording objects from the server
        function GetLocalRecordingState(recordings) {
            var result = { recordings:[]};
            var recordingResults = result.recordings;

            var possibleAnswers = ['HQ', 'RT', 'MISSING', 'PARTIALLY_MISSING'];

            $.each(recordings, function(i, recording) {
                // just make up a random yes-hq/yes-rt/missing answer
                var recordingResult = {};
                recordingResult['aggregate_state'] = possibleAnswers[Math.floor((Math.random()*4))];
                recordingResults.push(recordingResult);
            })

            return result;
        }

        function OpenRecording(claimedRecording) {
            return {success: true}
        }
        function PreviewRecording(claimedRecording) {
          return OpenRecording(claimedRecording);
        }
        function CloseRecording() {}
        function ClosePreviewRecording() {CloseRecording();}
        function OnDownloadAvailable() {}
        function SaveToClipboard(text) {}
        function IsNativeClient() { /* must always return false in all scenarios due to not ruin scoring !*/ return false; }
        function IsAudioStarted() { logger.debug("FakeJamClient: IsAudioStarted"); return false; }
        function StopAudio() {logger.debug("FakeJamClient: StopAudio"); }
        function ResetPageCounters() {logger.debug("FakeJamClient: ResetPageCounters"); }
        function ReloadAudioSystem(leaveRunning, loadLastProfile, reinitAssignments) {logger.debug("FakeJamClient: ReloadAudioSystem"); return {};}
        function SessionLiveBroadcastStart(host, port, mount, sourceUser, sourcePass, preferredClientId, bitrate)
        {
            logger.debug("SessionLiveBroadcastStart requested");
        }

        function SessionLiveBroadcastStop() {
            logger.debug("SessionLiveBroadcastStop requested");
        }

        function RegisterQuitCallback() { }
        function LeaveSessionAndMinimize() {}
        function SetAutoStart() {}
        function GetAutoStart() { return true; }
        function SaveSettings() {}

        // Javascript Bridge seems to camel-case
        // Set the instance functions:
        this.AbortRecording = AbortRecording;
        this.OnTrySyncCommand = OnTrySyncCommand;
        this.GetRecordingManagerState = GetRecordingManagerState;
        this.GetASIODevices = GetASIODevices;
        this.GetOS = GetOS;
        this.GetOSAsString = GetOSAsString;
        this.JoinSession = JoinSession;
        this.LatencyUpdated = LatencyUpdated;
        this.LeaveSession = LeaveSession;
        this.P2PMessageReceived = P2PMessageReceived;
        this.ParticipantJoined = ParticipantJoined;
        this.ParticipantLeft = ParticipantLeft;
        this.RecordTestBegin = RecordTestBegin;
        this.RecordTestEnd = RecordTestEnd;
        this.RecordTestPlayback = RecordTestPlayback;
        this.RegisterVolChangeCallBack = RegisterVolChangeCallBack;
        this.SendP2PMessage = SendP2PMessage;
        this.SetASIOEnabled = SetASIOEnabled;
        this.SignalLatencyUpdated = SignalLatencyUpdated;
        this.SignalSendP2PMessage = SignalSendP2PMessage;
        this.StartPlayTest = StartPlayTest;
        this.StartRecordTest = StartRecordTest;
        this.StartRecording = StartRecording;
        this.StopPlayTest = StopPlayTest;
        this.StopRecording = StopRecording;
        this.TestASIOLatency = TestASIOLatency;
        this.TestLatency = TestLatency;
        this.IsMyNetworkWireless = IsMyNetworkWireless;
        this.SetNetworkTestScore = SetNetworkTestScore;
        this.GetNetworkTestScore = GetNetworkTestScore;
        this.SetLatencyTestBlocked = SetLatencyTestBlocked;
        this.isLatencyTestBlocked = isLatencyTestBlocked;
        this.GetLastLatencyTestTimes =  GetLastLatencyTestTimes;
        this.RegisterQuitCallback = RegisterQuitCallback;
        this.LeaveSessionAndMinimize = LeaveSessionAndMinimize;
        this.GetAutoStart = GetAutoStart;
        this.SetAutoStart = SetAutoStart;
        this.connected = true;

        // FTUE (round 3)
        this.FTUESetInputMusicDevice = FTUESetInputMusicDevice;
        this.FTUESetOutputMusicDevice = FTUESetOutputMusicDevice;
        this.FTUEGetInputMusicDevice = FTUEGetInputMusicDevice;
        this.FTUEGetOutputMusicDevice = FTUEGetOutputMusicDevice;
        this.FTUEGetChatInputVolume = FTUEGetChatInputVolume;
        this.FTUEGetChatInputs = FTUEGetChatInputs;
        this.FTUEGetChannels = FTUEGetChannels;
        this.FTUEGetAudioDevices = FTUEGetAudioDevices;
        this.FTUEStartIoPerfTest = FTUEStartIoPerfTest;
        this.FTUEGetIoPerfData = FTUEGetIoPerfData;
        this.FTUEGetDevices = FTUEGetDevices;
        this.FTUEGetFrameSize = FTUEGetFrameSize;
        this.FTUECancel = FTUECancel;
        this.FTUEPageEnter = FTUEPageEnter;
        this.FTUEPageLeave = FTUEPageLeave;
        this.FTUEGetMusicProfileName = FTUEGetMusicProfileName;
        this.FTUESetMusicProfileName = FTUESetMusicProfileName;
        this.FTUESetPreferredMixerSampleRate = FTUESetPreferredMixerSampleRate;
        this.FTUESetPreferredOutputSampleRate = FTUESetPreferredOutputSampleRate;
        this.FTUESetPreferredChatSampleRate = FTUESetPreferredChatSampleRate;
        this.FTUEgetInputDeviceSampleRate = FTUEgetInputDeviceSampleRate;
        this.FTUEgetOutputDeviceSampleRate = FTUEgetOutputDeviceSampleRate;
        this.FTUEGetInputLatency = FTUEGetInputLatency;
        this.FTUEGetInputVolume = FTUEGetInputVolume;
        this.FTUEGetMusicInputs = FTUEGetMusicInputs;
        this.FTUEGetMusicOutputs = FTUEGetMusicOutputs;
        this.FTUEGetOutputLatency = FTUEGetOutputLatency;
        this.FTUEGetOutputVolume = FTUEGetOutputVolume;
        this.FTUEGetStatus = FTUEGetStatus;
        this.FTUEGetVolumeRanges = FTUEGetVolumeRanges;
        this.FTUEHasControlPanel = FTUEHasControlPanel;
        this.FTUEInit = FTUEInit;
        this.FTUEOpenControlPanel = FTUEOpenControlPanel;
        this.FTUERegisterLatencyCallback = FTUERegisterLatencyCallback;
        this.FTUERegisterVUCallbacks = FTUERegisterVUCallbacks;
        this.FTUERefreshDevices = FTUERefreshDevices;
        this.FTUESave = FTUESave;
        this.FTUESetChatInput = FTUESetChatInput;
        this.FTUESetChatInputVolume = FTUESetChatInputVolume;
        this.FTUESetInputVolume = FTUESetInputVolume;
        this.FTUESetFrameSize = FTUESetFrameSize;
        this.FTUESetInputLatency = FTUESetInputLatency;
        this.FTUESetMusicDevice = FTUESetMusicDevice;
        this.FTUESetMusicInput = FTUESetMusicInput;
        this.FTUESetMusicOutput = FTUESetMusicOutput;
        this.FTUESetOutputLatency = FTUESetOutputLatency;
        this.FTUESetOutputVolume = FTUESetOutputVolume;
        this.FTUESetStatus = FTUESetStatus;
        this.FTUEStartLatency = FTUEStartLatency;
        this.FTUEGetExpectedLatency = FTUEGetExpectedLatency;
        this.FTUEGetGoodConfigurationList = FTUEGetGoodConfigurationList;
        this.FTUEGetAllAudioConfigurations = FTUEGetAllAudioConfigurations;
        this.FTUEGetGoodAudioConfigurations = FTUEGetGoodAudioConfigurations;
        this.FTUEGetConfigurationDevice = FTUEGetConfigurationDevice;
        this.FTUEIsMusicDeviceWDM = FTUEIsMusicDeviceWDM;
        this.FTUELoadAudioConfiguration = FTUELoadAudioConfiguration;
        this.FTUEClearChannelAssignments = FTUEClearChannelAssignments;
        this.FTUEClearChatInput = FTUEClearChatInput;
        this.FTUECreateUpdatePlayBackProfile = FTUECreateUpdatePlayBackProfile;

        // Session
        this.SessionAddTrack = SessionAddTrack;
        this.SessionCurrrentJamTrackPlayPosMs = SessionCurrrentJamTrackPlayPosMs;
        this.SessionGetJamTracksPlayDurationMs = SessionGetJamTracksPlayDurationMs;
        this.SessionGetControlState = SessionGetControlState;
        this.SessionGetAllControlState = SessionGetAllControlState;
        this.SessionSetUserName = SessionSetUserName;
        this.SessionGetIDs = SessionGetIDs;
        this.RegisterRecordingManagerCallbacks = RegisterRecordingManagerCallbacks;
        this.RegisterRecordingCallbacks = RegisterRecordingCallbacks;
        this.SessionRegisterCallback = SessionRegisterCallback;
        this.SessionSetAlertCallback = SessionSetAlertCallback;
        this.SessionSetControlState = SessionSetControlState;
        this.SessionSetRecordingFilename = SessionSetRecordingFilename;
        this.SessionSetRecordingFolder = SessionSetRecordingFolder;
        this.SessionStartPlay = SessionStartPlay;
        this.SessionStartRecording = SessionStartRecording;
        this.SessionStopPlay = SessionStopPlay;
        this.SessionAddPlayTrack = SessionAddPlayTrack;
        this.SessionRemoveAllPlayTracks = SessionRemoveAllPlayTracks;
        this.SessionStopRecording = SessionStopRecording;
        this.isSessionTrackPlaying = isSessionTrackPlaying;
        this.SessionCurrrentPlayPosMs = SessionCurrrentPlayPosMs;
        this.SessionGetTracksPlayDurationMs = SessionGetTracksPlayDurationMs;
        this.SessionPageEnter = SessionPageEnter;
        this.SessionPageLeave = SessionPageLeave;
        this.SetMixerMode = SetMixerMode;

        this.SetVURefreshRate = SetVURefreshRate;
        this.SessionGetMasterLocalMix = SessionGetMasterLocalMix;
        this.SessionSetMasterLocalMix = SessionSetMasterLocalMix;
        this.SessionGetDeviceLatency = SessionGetDeviceLatency;
        this.SessionAudioResync = SessionAudioResync;

        // Track
        this.TrackGetChannels = TrackGetChannels;
        this.TrackSetAssignment = TrackSetAssignment;
        this.TrackGetAssignment = TrackGetAssignment;
        this.TrackSetCount = TrackSetCount;
        this.TrackGetCount = TrackGetCount;
        this.TrackSave = TrackSave;
        this.TrackLoadAssignments = TrackLoadAssignments;
        this.TrackSetInstrument = TrackSetInstrument;
        this.TrackGetInstrument = TrackGetInstrument;
        this.TrackSaveAssignments = TrackSaveAssignments;

        this.TrackGetDevices = TrackGetDevices;
        this.TrackDeleteProfile = TrackDeleteProfile;
        this.TrackGetMusicDeviceID = TrackGetMusicDeviceID;
        this.TrackSetMusicDevice = TrackSetMusicDevice;
        this.TrackGetMusicDeviceNames = TrackGetMusicDeviceNames;
        this.TrackHasControlPanel = TrackHasControlPanel;
        this.TrackOpenControlPanel = TrackOpenControlPanel;
        this.TrackIsMusicDeviceType = TrackIsMusicDeviceType;

        this.TrackGetChatEnable = TrackGetChatEnable;
        this.TrackSetChatEnable = TrackSetChatEnable;

        this.TrackGetChatUsesMusic = TrackGetChatUsesMusic;
        this.TrackSetChatUsesMusic = TrackSetChatUsesMusic;

        this.JamTrackStopPlay = JamTrackStopPlay;
        this.JamTrackPlay = JamTrackPlay;
        this.JamTrackIsPlayable = JamTrackIsPlayable;
        this.JamTrackGetTrackDetail = JamTrackGetTrackDetail;
        this.JamTrackKeysRequest = JamTrackKeysRequest;
        this.JamTrackDownload = JamTrackDownload;

        // Scoring Knobs
        this.GetScoreWorkTimingInterval = GetScoreWorkTimingInterval;
        this.SetScoreWorkTimingInterval = SetScoreWorkTimingInterval;

        // Backing tracks:
        this.getBackingTrackList = getBackingTrackList;
        this.SessionCloseBackingTrackFile = SessionCloseBackingTrackFile;
        this.SessionOpenBackingTrackFile = SessionOpenBackingTrackFile;
        this.SessionSetBackingTrackFileLoop = SessionSetBackingTrackFileLoop;

        // Metronome:
        this.SessionCloseMetronome = SessionCloseMetronome;
        this.SessionOpenMetronome = SessionOpenMetronome;
        this.SessionSetMetronome = SessionSetMetronome;
        this.setMetronomeOpenCallback = setMetronomeOpenCallback;
        this.getMyNetworkState = getMyNetworkState;
        this.getPeerState = getPeerState;

        // Client Update
        this.IsAppInWritableVolume = IsAppInWritableVolume;
        this.ClientUpdateVersion = ClientUpdateVersion;
        this.ClientUpdateStartDownload = ClientUpdateStartDownload;
        this.ClientUpdateStartUpdate = ClientUpdateStartUpdate;

        this.OpenSystemBrowser = OpenSystemBrowser;
        this.RestartApplication = RestartApplication;
        this.ShutdownApplication = ShutdownApplication;

        // Websocket/Auth sessions
        this.OnLoggedIn = OnLoggedIn;
        this.OnLoggedOut = OnLoggedOut;

        this.UserAttention = UserAttention;
        this.IsFrontendVisible = IsFrontendVisible;
        this.LastUsedProfileName = LastUsedProfileName;
        this.SetLastUsedProfileName = SetLastUsedProfileName;

        // Recording Playback
        this.GetLocalRecordingState = GetLocalRecordingState;
        this.OpenRecording = OpenRecording;
        this.CloseRecording = CloseRecording;
        this.PreviewRecording = PreviewRecording;
        this.ClosePreviewRecording = ClosePreviewRecording;
        this.OnDownloadAvailable = OnDownloadAvailable;

        // Video functionality:
        this.FTUESelectVideoCaptureDevice = FTUESelectVideoCaptureDevice
        this.FTUESetVideoEncodeResolution = FTUESetVideoEncodeResolution;
        this.FTUEGetVideoCaptureDeviceNames = FTUEGetVideoCaptureDeviceNames;
        this.FTUECurrentSelectedVideoDevice = FTUECurrentSelectedVideoDevice;
        this.FTUEGetAvailableEncodeVideoResolutions = FTUEGetAvailableEncodeVideoResolutions;
        this.FTUEGetVideoCaptureDeviceCapabilities = FTUEGetVideoCaptureDeviceCapabilities;
        

        this.isSessVideoShared = isSessVideoShared;
        this.SessStopVideoSharing = SessStopVideoSharing;
        this.SessStartVideoSharing = SessStartVideoSharing;

        // Clipboard
        this.SaveToClipboard = SaveToClipboard;

        // Capabilities
        this.IsNativeClient = IsNativeClient;

        // Audio
        this.IsAudioStarted = IsAudioStarted;
        this.StopAudio = StopAudio;
        this.ResetPageCounters = ResetPageCounters;
        this.ReloadAudioSystem = ReloadAudioSystem;

        // Broadcasting
        this.SessionLiveBroadcastStart = SessionLiveBroadcastStart;
        this.SessionLiveBroadcastStop = SessionLiveBroadcastStop;
        this.SessionSetConnectionStatusRefreshRate = SessionSetConnectionStatusRefreshRate;

        // fake calls; not a part of the actual jam client
        this.RegisterP2PMessageCallbacks = RegisterP2PMessageCallbacks;
        this.SetFakeRecordingImpl = SetFakeRecordingImpl;

        // network test
        this.TestNetworkPktBwRate = TestNetworkPktBwRate;
        this.StopNetworkTest = StopNetworkTest;
        this.log = log;
        this.getOperatingMode = getOperatingMode;
        this.clientID = "devtester";
    };

 })(window,jQuery);