/*
 *
 * 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.
 *
 */

/* global cordova, Windows, Media, MediaError, LocalFileSystem, halfSpeedBtn */

// increased timeout for actual playback to give device chance to download and play mp3 file
// some emulators can be REALLY slow at this, so two minutes
var ACTUAL_PLAYBACK_TEST_TIMEOUT = 2 * 60 * 1000;

var WEB_MP3_FILE = 'https://cordova.apache.org/downloads/BlueZedEx.mp3';
var WEB_MP3_STREAM = 'https://cordova.apache.org/downloads/BlueZedEx.mp3';

var isWindows = cordova.platformId === 'windows8' || cordova.platformId === 'windows';
var isBrowser = cordova.platformId === 'browser';
// Detect whether audio hardware is available and enabled. For iOS playing audio is
// not supported on emulators w/out sound device connected to host PC but (which is
// the case for Sauce Labs emulators - see CB-11430)
var isAudioSupported = isWindows
    ? !!Windows.Media.Devices.MediaDevice.getDefaultAudioRenderId(Windows.Media.Devices.AudioDeviceRole.default)
    : cordova.platformId === 'ios'
        ? !window.SAUCELABS_ENV
        : true;

var isKitKat = cordova.platformId === 'android' && /Android\s4\.4/.test(window.navigator.userAgent);

exports.defineAutoTests = function () {
    var failed = function (done, msg, context) {
        if (context && context.done) return;
        context.done = true;
        var info = typeof msg === 'undefined' ? 'Unexpected error callback' : msg;
        expect(true).toFailWithMessage(info);
        done();
    };

    var succeed = function (done, msg, context) {
        if (context && context.done) return;
        context.done = true;
        var info = typeof msg === 'undefined' ? 'Unexpected success callback' : msg;
        expect(true).toFailWithMessage(info);
        done();
    };

    describe('Media', function () {
        beforeEach(function () {
            // Custom Matcher
            jasmine.Expectation.addMatchers({
                toFailWithMessage: function () {
                    return {
                        compare: function (_, message) {
                            var pass = false;
                            return {
                                pass: pass,
                                message: message
                            };
                        }
                    };
                }
            });
        });

        it('media.spec.1 should exist', function () {
            expect(Media).toBeDefined();
            expect(typeof Media).toBe('function');
        });

        it('media.spec.2 should have the following properties', function () {
            var media1 = new Media('dummy');
            expect(media1.id).toBeDefined();
            expect(media1.src).toBeDefined();
            expect(media1._duration).toBeDefined();
            expect(media1._position).toBeDefined();
            media1.release();
        });

        it('media.spec.3 should define constants for Media status', function () {
            expect(Media).toBeDefined();
            expect(Media.MEDIA_NONE).toBe(0);
            expect(Media.MEDIA_STARTING).toBe(1);
            expect(Media.MEDIA_RUNNING).toBe(2);
            expect(Media.MEDIA_PAUSED).toBe(3);
            expect(Media.MEDIA_STOPPED).toBe(4);
        });

        it('media.spec.4 should define constants for Media errors', function () {
            expect(MediaError).toBeDefined();
            expect(MediaError.MEDIA_ERR_NONE_ACTIVE).toBe(0);
            expect(MediaError.MEDIA_ERR_ABORTED).toBe(1);
            expect(MediaError.MEDIA_ERR_NETWORK).toBe(2);
            expect(MediaError.MEDIA_ERR_DECODE).toBe(3);
            expect(MediaError.MEDIA_ERR_NONE_SUPPORTED).toBe(4);
        });

        it('media.spec.5 should contain a play function', function () {
            var media1 = new Media('dummy');
            expect(media1.play).toBeDefined();
            expect(typeof media1.play).toBe('function');
            media1.release();
        });

        it('media.spec.6 should contain a stop function', function () {
            var media1 = new Media('dummy');
            expect(media1.stop).toBeDefined();
            expect(typeof media1.stop).toBe('function');
            media1.release();
        });

        it('media.spec.7 should contain a seekTo function', function () {
            var media1 = new Media('dummy');
            expect(media1.seekTo).toBeDefined();
            expect(typeof media1.seekTo).toBe('function');
            media1.release();
        });

        it('media.spec.8 should contain a pause function', function () {
            var media1 = new Media('dummy');
            expect(media1.pause).toBeDefined();
            expect(typeof media1.pause).toBe('function');
            media1.release();
        });

        it('media.spec.9 should contain a getDuration function', function () {
            var media1 = new Media('dummy');
            expect(media1.getDuration).toBeDefined();
            expect(typeof media1.getDuration).toBe('function');
            media1.release();
        });

        it('media.spec.10 should contain a getCurrentPosition function', function () {
            var media1 = new Media('dummy');
            expect(media1.getCurrentPosition).toBeDefined();
            expect(typeof media1.getCurrentPosition).toBe('function');
            media1.release();
        });

        it('media.spec.11 should contain a startRecord function', function () {
            var media1 = new Media('dummy');
            expect(media1.startRecord).toBeDefined();
            expect(typeof media1.startRecord).toBe('function');
            media1.release();
        });

        it('media.spec.12 should contain a stopRecord function', function () {
            var media1 = new Media('dummy');
            expect(media1.stopRecord).toBeDefined();
            expect(typeof media1.stopRecord).toBe('function');
            media1.release();
        });

        it('media.spec.13 should contain a release function', function () {
            var media1 = new Media('dummy');
            expect(media1.release).toBeDefined();
            expect(typeof media1.release).toBe('function');
            media1.release();
        });

        it('media.spec.14 should contain a setVolume function', function () {
            var media1 = new Media('dummy');
            expect(media1.setVolume).toBeDefined();
            expect(typeof media1.setVolume).toBe('function');
            media1.release();
        });

        it('media.spec.15 should contain a getCurrentAmplitude function', function () {
            var media1 = new Media('dummy');
            expect(media1.getCurrentAmplitude).toBeDefined();
            expect(typeof media1.getCurrentAmplitude).toBe('function');
            media1.release();
        });

        it('media.spec.16 should contain a pauseRecord function', function () {
            var media1 = new Media('dummy');
            expect(media1.pauseRecord).toBeDefined();
            expect(typeof media1.pauseRecord).toBe('function');
            media1.release();
        });

        it('media.spec.17 should contain a resumeRecord function', function () {
            var media1 = new Media('dummy');
            expect(media1.resumeRecord).toBeDefined();
            expect(typeof media1.resumeRecord).toBe('function');
            media1.release();
        });

        it('media.spec.18 should return MediaError for bad filename', function (done) {
            // bb10 dialog pops up, preventing tests from running
            if (cordova.platformId === 'blackberry10') {
                pending();
            }

            var context = this;
            var fileName = 'invalid.file.name';
            var badMedia = new Media(
                fileName,
                succeed.bind(
                    null,
                    done,
                    ' badMedia = new Media , Unexpected succees callback, it should not create Media object with invalid file name'
                ),
                function (result) {
                    if (context.done) return;
                    context.done = true;

                    expect(result).toBeDefined();
                    expect(result.code).toBe(MediaError.MEDIA_ERR_ABORTED);
                    if (badMedia) {
                        badMedia.release();
                    }
                    done();
                }
            );
            badMedia.play();
        });

        describe('actual playback', function () {
            var checkInterval, media;

            afterEach(function () {
                clearInterval(checkInterval);
                if (media) {
                    media.stop();
                    media.release();
                    media = null;
                }
            });

            it(
                'media.spec.19 position should be set properly',
                function (done) {
                    // no audio hardware available
                    if (!isAudioSupported || isBrowser || isKitKat) {
                        pending();
                    }

                    // context variable used as an extra security statement to ensure that the callback is processed only once,
                    // in case the statusChange callback is reached more than one time with the same status code.
                    // Some information about this kind of behaviour can be found at JIRA: CB-7099.
                    var context = this;
                    var mediaFile = WEB_MP3_FILE;
                    var successCallback = function () {};
                    var statusChange = function (statusCode) {
                        if (!context.done && statusCode === Media.MEDIA_RUNNING) {
                            checkInterval = setInterval(function () {
                                if (context.done) return;
                                media.getCurrentPosition(function successCallback (position) {
                                    if (position > 0.0) {
                                        context.done = true;
                                        expect(true).toBe(true);
                                        done();
                                    }
                                }, failed.bind(null, done, 'media1.getCurrentPosition - Error getting media current position', context));
                            }, 1000);
                        }
                    };
                    media = new Media(
                        mediaFile,
                        successCallback,
                        failed.bind(null, done, 'media1 = new Media - Error creating Media object. Media file: ' + mediaFile, context),
                        statusChange
                    );
                    media.play();
                },
                ACTUAL_PLAYBACK_TEST_TIMEOUT
            );

            it(
                'media.spec.20 duration should be set properly',
                function (done) {
                    if (!isAudioSupported || cordova.platformId === 'blackberry10' || isBrowser || isKitKat) {
                        pending();
                    }

                    // context variable used as an extra security statement to ensure that the callback is processed only once,
                    // in case the statusChange callback is reached more than one time with the same status code.
                    // Some information about this kind of behaviour can be found at JIRA: CB-7099.
                    var context = this;
                    var mediaFile = WEB_MP3_FILE;
                    var successCallback = function () {};
                    var statusChange = function (statusCode) {
                        if (!context.done && statusCode === Media.MEDIA_RUNNING) {
                            checkInterval = setInterval(function () {
                                if (context.done) return;
                                media.getCurrentPosition(function (position) {
                                    if (position > 0.0) {
                                        context.done = true;
                                        expect(media.getDuration()).toBeGreaterThan(0.0);
                                        done();
                                    }
                                }, failed.bind(null, done, 'media1.getCurrentPosition - Error getting media current position', context));
                            }, 1000);
                        }
                    };
                    media = new Media(
                        mediaFile,
                        successCallback,
                        failed.bind(null, done, 'media1 = new Media - Error creating Media object. Media file: ' + mediaFile, context),
                        statusChange
                    );
                    media.play();
                },
                ACTUAL_PLAYBACK_TEST_TIMEOUT
            );

            it(
                'media.spec.21 should be able to resume playback after pause',
                function (done) {
                    if (!isAudioSupported || cordova.platformId === 'blackberry10' || isKitKat) {
                        pending();
                    }

                    // context variable used as an extra security statement to ensure that the callback is processed only once,
                    // in case the statusChange callback is reached more than one time with the same status code.
                    // Some information about this kind of behaviour can be found at JIRA: CB-7099.
                    var context = this;
                    var resumed = false;
                    var mediaFile = WEB_MP3_FILE;
                    var successCallback = function () {};
                    var statusChange = function (statusCode) {
                        if (context.done) return;

                        if (statusCode === Media.MEDIA_RUNNING) {
                            if (!resumed) {
                                media.seekTo(20000);
                                media.pause();
                                return;
                            }

                            media.getCurrentPosition(function (position) {
                                expect(position).toBeGreaterThan(19);
                                expect(position).toBeLessThan(21);
                                context.done = true;
                                done();
                            }, failed.bind(null, done, 'media1.getCurrentPosition - Error getting media current position', context));
                        }

                        if (statusCode === Media.MEDIA_PAUSED) {
                            resumed = true;
                            media.play();
                        }
                    };
                    media = new Media(
                        mediaFile,
                        successCallback,
                        failed.bind(null, done, 'media1 = new Media - Error creating Media object. Media file: ' + mediaFile, context),
                        statusChange
                    );

                    // CB-10535: Play after a few secs, to give allow enough buffering of media file before seeking
                    setTimeout(function () {
                        media.play();
                    }, 4000);
                },
                ACTUAL_PLAYBACK_TEST_TIMEOUT
            );

            it(
                'media.spec.22 should be able to seek through file',
                function (done) {
                    if (!isAudioSupported || cordova.platformId === 'blackberry10' || isKitKat) {
                        pending();
                    }

                    // context variable used as an extra security statement to ensure that the callback is processed only once,
                    // in case the statusChange callback is reached more than one time with the same status code.
                    // Some information about this kind of behaviour can be found at JIRA: CB-7099.
                    var context = this;
                    var mediaFile = WEB_MP3_FILE;
                    var successCallback = function () {};
                    var statusChange = function (statusCode) {
                        if (!context.done && statusCode === Media.MEDIA_RUNNING) {
                            checkInterval = setInterval(function () {
                                if (context.done) return;
                                media.seekTo(5000);
                                media.getCurrentPosition(function (position) {
                                    expect(position).toBeCloseTo(5, 0);
                                    context.done = true;
                                    done();
                                }, failed.bind(null, done, 'media1.getCurrentPosition - Error getting media current position', context));
                            }, 1000);
                        }
                    };
                    media = new Media(
                        mediaFile,
                        successCallback,
                        failed.bind(null, done, 'media1 = new Media - Error creating Media object. Media file: ' + mediaFile, context),
                        statusChange
                    );

                    // CB-10535: Play after a few secs, to give allow enough buffering of media file before seeking
                    setTimeout(function () {
                        media.play();
                    }, 4000);
                },
                ACTUAL_PLAYBACK_TEST_TIMEOUT
            );
        });

        it('media.spec.23 should contain a setRate function', function () {
            var media1 = new Media('dummy');
            expect(media1.setRate).toBeDefined();
            expect(typeof media1.setRate).toBe('function');
            media1.release();
        });

        it(
            'media.spec.24 playback rate should be set properly using setRate',
            function (done) {
                if (cordova.platformId !== 'ios') {
                    expect(true).toFailWithMessage('Platform does not supported this feature');
                    pending();
                }

                // no audio hardware available
                if (!isAudioSupported) {
                    pending();
                }

                var mediaFile = WEB_MP3_FILE;
                var successCallback;
                var context = this;
                var flag = true;
                var statusChange = function (statusCode) {
                    console.log('status code: ' + statusCode);
                    if (statusCode === Media.MEDIA_RUNNING && flag) {
                        // flag variable used to ensure an extra security statement to ensure that the callback is processed only once,
                        // in case for some reason the statusChange callback is reached more than one time with the same status code.
                        // Some information about this kind of behavior it can be found at JIRA: CB-7099
                        flag = false;
                        setTimeout(function () {
                            media1.getCurrentPosition(
                                function (position) {
                                    // in four seconds expect position to be between 4 & 10. Here, the values are chosen to give
                                    // a large enough buffer range for the position to fall in and are not based on any calculation.
                                    expect(position).not.toBeLessThan(4);
                                    expect(position).toBeLessThan(10);
                                    media1.stop();
                                    media1.release();
                                    context.done = true;
                                    done();
                                },
                                failed.bind(null, done, 'media1.getCurrentPosition - Error getting media current position'),
                                context
                            );
                        }, 4000);
                    }
                };

                var media1 = new Media(
                    mediaFile,
                    successCallback,
                    failed.bind(null, done, 'media1 = new Media - Error creating Media object. Media file: ' + mediaFile, context),
                    statusChange
                );
                // make audio playback two times faster
                media1.setRate(2);
                media1.play();
            },
            ACTUAL_PLAYBACK_TEST_TIMEOUT
        );

        it(
            'media.spec.25 should be able to play an audio stream',
            function (done) {
                // no audio hardware available, OR
                // O_o Safari can't play the stream, so we're skipping this test on all browsers o_O
                if (!isAudioSupported || isBrowser || isKitKat) {
                    pending();
                }

                // The link below points to an infinite mp3 stream
                var mediaFile = WEB_MP3_STREAM;
                var successCallback;
                var context = this;
                var flag = true;
                var statusChange = function (statusCode) {
                    console.log('status code: ' + statusCode);
                    if (statusCode === Media.MEDIA_RUNNING && flag) {
                        // flag variable used to ensure an extra security statement to ensure that the callback is processed only once,
                        // in case for some reason the statusChange callback is reached more than one time with the same status code.
                        // Some information about this kind of behavior it can be found at JIRA: CB-7099
                        flag = false;
                        expect(true).toBe(true);
                        media1.stop();
                        media1.release();
                        context.done = true;
                        done();
                    }
                };

                var media1 = new Media(
                    mediaFile,
                    successCallback,
                    failed.bind(null, done, 'media1 = new Media - Error creating Media object. Media file: ' + mediaFile, context),
                    statusChange
                );
                media1.play();
            },
            ACTUAL_PLAYBACK_TEST_TIMEOUT
        );

        it('media.spec.26 should not crash or throw when setting the volume right after creating the media', function (done) {
            // bb10 dialog pops up, preventing tests from running
            if (cordova.platformId === 'blackberry10') {
                pending();
            }

            var mediaFile = WEB_MP3_FILE;
            var media = null;

            expect(function () {
                media = new Media(mediaFile);
                media.setVolume('0.5');
            }).not.toThrow();

            // if there is no exception or crash in 3 seconds, the spec is completed
            setTimeout(function () {
                if (media) {
                    media.release();
                    done();
                }
            }, 3000);
        });

        it('media.spec.27 should call success or error when trying to stop a media that is in starting state', function (done) {
            // bb10 dialog pops up, preventing tests from running
            if (!isAudioSupported || cordova.platformId === 'blackberry10') {
                pending();
            }

            var mediaFile = WEB_MP3_FILE;
            var media = null;
            var context = this;
            var beenStarting = false;
            var safeDone = function () {
                if (!context.done) {
                    media.release();
                    context.done = true;
                    done();
                }
            };

            var errorCallback = jasmine.createSpy('errorCallback').and.callFake(function (e) {
                expect(true).toBe(true);
                safeDone();
            });
            var successCallback = function () {
                expect(true).toBe(true);
                safeDone();
            };
            var statusChange = function (s) {
                if (s === Media.MEDIA_STARTING && !context.done) {
                    beenStarting = true;
                    media.stop();
                } else if (s === Media.MEDIA_RUNNING) {
                    // Some plugin implementations may skip "Starting" state
                    // so we'll also try to call stop in "Running" state,
                    // but in this case we should check that the "Starting" state wasn't really reached,
                    // otherwise it would mean that the previous media.stop() call has been ignored
                    expect(beenStarting).toBe(false);
                    media.stop();
                }
            };

            media = new Media(mediaFile, successCallback, errorCallback, statusChange);
            media.play();
        });
    });
};

//* *****************************************************************************************
//* **************************************Manual Tests***************************************
//* *****************************************************************************************

exports.defineManualTests = function (contentEl, createActionButton) {
    // -------------------------------------------------------------------------
    // Audio player
    // -------------------------------------------------------------------------
    var media1 = null;
    var media1Timer = null;
    var audioSrc = null;
    var defaultaudio = WEB_MP3_FILE;

    // Play audio function
    function playAudio (url) {
        console.log('playAudio()');
        console.log(' -- media=' + media1);

        var src = defaultaudio;

        if (url) {
            src = url;
        }

        // Stop playing if src is different from currently playing source
        if (src !== audioSrc) {
            if (media1 !== null) {
                stopAudio();
                media1 = null;
            }
        }

        if (media1 === null) {
            // TEST STREAMING AUDIO PLAYBACK
            // var src = "http://nunzioweb.com/misc/Bon_Jovi-Crush_Mystery_Train.mp3";   // works
            // var src = "http://nunzioweb.com/misc/Bon_Jovi-Crush_Mystery_Train.m3u"; // doesn't work
            // var src = "http://www.wav-sounds.com/cartoon/bugsbunny1.wav"; // works
            // var src = "http://www.angelfire.com/fl5/html-tutorial/a/couldyou.mid"; // doesn't work
            // var src = "MusicSearch/mp3/train.mp3";    // works
            // var src = "bryce.mp3";  // works
            // var src = "/android_asset/www/bryce.mp3"; // works

            media1 = new Media(
                src,
                function () {
                    console.log('playAudio():Audio Success');
                },
                function (err) {
                    console.log('playAudio():Audio Error: ' + err.code);
                    setAudioStatus('Error: ' + err.code);
                },
                function (status) {
                    console.log('playAudio():Audio Status: ' + status);
                    setAudioStatus(Media.MEDIA_MSG[status]);

                    // If stopped, then stop getting current position
                    if (Media.MEDIA_STOPPED === status) {
                        clearInterval(media1Timer);
                        media1Timer = null;
                        setAudioPosition('0 sec');
                    }
                }
            );
        }
        audioSrc = src;
        document.getElementById('durationValue').innerHTML = '';
        // Play audio
        media1.play();
        if (media1Timer === null && media1.getCurrentPosition) {
            media1Timer = setInterval(function () {
                media1.getCurrentPosition(
                    function (position) {
                        if (position >= 0.0) {
                            setAudioPosition(position + ' sec');
                        }
                    },
                    function (e) {
                        console.log('Error getting pos=' + e);
                        setAudioPosition('Error: ' + e);
                    }
                );
            }, 1000);
        }

        // Get duration
        var counter = 0;
        var timerDur = setInterval(function () {
            counter = counter + 100;
            if (counter > 2000) {
                clearInterval(timerDur);
            }
            var dur = media1.getDuration();
            if (dur > 0) {
                clearInterval(timerDur);
                document.getElementById('durationValue').innerHTML = dur + ' sec';
            }
        }, 100);
    }

    // Pause audio playback
    function pauseAudio () {
        console.log('pauseAudio()');
        if (media1) {
            media1.pause();
        }
    }

    // Stop audio
    function stopAudio () {
        console.log('stopAudio()');
        if (media1) {
            media1.stop();
        }
        clearInterval(media1Timer);
        media1Timer = null;
    }

    // Release audio
    function releaseAudio () {
        console.log('releaseAudio()');
        if (media1) {
            media1.stop(); // imlied stop of playback, resets timer
            media1.release();
        }
    }

    // Set audio status
    function setAudioStatus (status) {
        document.getElementById('statusValue').innerHTML = status;
    }

    // Set audio position
    function setAudioPosition (position) {
        document.getElementById('positionValue').innerHTML = position;
    }

    // Seek audio
    function seekAudio (mode) {
        var time = document.getElementById('seekInput').value;
        if (time === '') {
            time = 5000;
        } else {
            time = time * 1000; // we expect the input to be in seconds
        }
        if (media1 === null) {
            console.log('seekTo requested while media1 is null');
            if (audioSrc === null) {
                audioSrc = defaultaudio;
            }
            media1 = new Media(
                audioSrc,
                function () {
                    console.log('seekToAudio():Audio Success');
                },
                function (err) {
                    console.log('seekAudio():Audio Error: ' + err.code);
                    setAudioStatus('Error: ' + err.code);
                },
                function (status) {
                    console.log('seekAudio():Audio Status: ' + status);
                    setAudioStatus(Media.MEDIA_MSG[status]);

                    // If stopped, then stop getting current position
                    if (Media.MEDIA_STOPPED === status) {
                        clearInterval(media1Timer);
                        media1Timer = null;
                        setAudioPosition('0 sec');
                    }
                }
            );
        }

        media1.getCurrentPosition(
            function (position) {
                var deltat = time;
                if (mode === 'by') {
                    deltat = time + position * 1000;
                }
                media1.seekTo(
                    deltat,
                    function () {
                        console.log('seekAudioTo():Audio Success');
                        // force an update on the position display
                        updatePosition();
                    },
                    function (err) {
                        console.log('seekAudioTo():Audio Error: ' + err.code);
                    }
                );
            },
            function (e) {
                console.log('Error getting pos=' + e);
                setAudioPosition('Error: ' + e);
            }
        );
    }

    // set audio volume
    function setVolume () {
        console.log('setVolume()');
        var volume = document.getElementById('volumeInput').value;
        if (media1 !== null) {
            media1.setVolume(volume);
        }
    }

    // for forced updates of position after a successful seek

    function updatePosition () {
        media1.getCurrentPosition(
            function (position) {
                if (position >= 0.0) {
                    setAudioPosition(position + ' sec');
                }
            },
            function (e) {
                console.log('Error getting pos=' + e);
                setAudioPosition('Error: ' + e);
            }
        );
    }

    // -------------------------------------------------------------------------
    // Audio recorder
    // -------------------------------------------------------------------------
    var mediaRec = null;
    var recTime = 0;
    var recordSrc = 'myRecording.mp3';

    // Record audio
    function recordAudio () {
        console.log('recordAudio(), recording to ' + recordSrc);
        console.log(' -- media=' + mediaRec);

        releaseAudio();

        if (!mediaRec) {
            mediaRec = new Media(
                recordSrc,
                function () {
                    console.log('recordAudio():Audio Success');
                },
                function (err) {
                    console.log('recordAudio():Audio Error: ' + err.code);
                    setAudioStatus('Error: ' + err.code);
                },
                function (status) {
                    console.log('recordAudio():Audio Status: ' + status);
                    setAudioStatus(Media.MEDIA_MSG[status]);
                }
            );
        }

        // Record audio
        mediaRec.startRecord();

        // Stop recording after 10 sec
        recTime = 0;
        var recInterval = setInterval(function () {
            recTime = recTime + 1;
            setAudioPosition(recTime + ' sec');
            if (recTime >= 10) {
                clearInterval(recInterval);
                if (mediaRec.stopAudioRecord) {
                    mediaRec.stopAudioRecord();
                } else {
                    mediaRec.stopRecord();
                }
                console.log('recordAudio(): stop');
            }
        }, 1000);
    }

    // Play back recorded audio
    function playRecording () {
        playAudio(recordSrc);
    }

    // Function to get a filename for iOS recording
    // Ensures that file doesn't exist to test CB-11380
    function getRecordSrc () {
        var noop = function () {};
        recordSrc = 'cdvfile://localhost/temporary/iOSRecording.wav';
        window.resolveLocalFileSystemURL(
            recordSrc,
            function (file) {
                file.remove(function () {
                    console.log('Successfully removed ' + recordSrc);
                }, noop);
            },
            noop
        );
    }

    // Function to create a file for BB recording
    function getRecordSrcBB () {
        var fsFail = function (error) {
            console.log('error creating file for BB recording', error);
        };
        var gotFile = function (file) {
            recordSrc = file.fullPath;
        };
        var gotFS = function (fileSystem) {
            fileSystem.root.getFile(
                'BBRecording.amr',
                {
                    create: true
                },
                gotFile,
                fsFail
            );
        };
        window.requestFileSystem(LocalFileSystem.TEMPORARY, 0, gotFS, fsFail);
    }

    // Function to create a file for Windows recording
    function getRecordSrcWin () {
        var fsFail = function (error) {
            console.log('error creating file for Win recording', error);
        };
        var gotFile = function (file) {
            recordSrc = file.name;
        };
        var gotFS = function (fileSystem) {
            fileSystem.root.getFile(
                'WinRecording.m4a',
                {
                    create: true
                },
                gotFile,
                fsFail
            );
        };
        window.requestFileSystem(LocalFileSystem.PERSISTENT, 0, gotFS, fsFail);
    }

    // Generate Dynamic Table
    function generateTable (tableId, rows, cells, elements) {
        var table = document.createElement('table');
        for (var r = 0; r < rows; r++) {
            var row = table.insertRow(r);
            for (var c = 0; c < cells; c++) {
                var cell = row.insertCell(c);
                cell.setAttribute('align', 'center');
                for (var e in elements) {
                    if (elements[e].position.row === r && elements[e].position.cell === c) {
                        var htmlElement = document.createElement(elements[e].tag);
                        var content;

                        if (elements[e].content !== '') {
                            content = document.createTextNode(elements[e].content);
                            htmlElement.appendChild(content);
                        }
                        if (elements[e].type) {
                            htmlElement.type = elements[e].type;
                        }
                        htmlElement.setAttribute('id', elements[e].id);
                        cell.appendChild(htmlElement);
                    }
                }
            }
        }
        table.setAttribute('align', 'center');
        table.setAttribute('id', tableId);
        return table;
    }

    // Audio && Record Elements
    var elementsResultsAudio = [
        {
            id: 'statusTag',
            content: 'Status:',
            tag: 'div',
            position: {
                row: 0,
                cell: 0
            }
        },
        {
            id: 'statusValue',
            content: '',
            tag: 'div',
            position: {
                row: 0,
                cell: 2
            }
        },
        {
            id: 'durationTag',
            content: 'Duration:',
            tag: 'div',
            position: {
                row: 1,
                cell: 0
            }
        },
        {
            id: 'durationValue',
            content: '',
            tag: 'div',
            position: {
                row: 1,
                cell: 2
            }
        },
        {
            id: 'positionTag',
            content: 'Position:',
            tag: 'div',
            position: {
                row: 2,
                cell: 0
            }
        },
        {
            id: 'positionValue',
            content: '',
            tag: 'div',
            position: {
                row: 2,
                cell: 2
            }
        }
    ];
    var elementsAudio = [
        {
            id: 'playBtn',
            content: '',
            tag: 'div',
            position: {
                row: 0,
                cell: 0
            }
        },
        {
            id: 'pauseBtn',
            content: '',
            tag: 'div',
            position: {
                row: 0,
                cell: 1
            }
        },
        {
            id: 'stopBtn',
            content: '',
            tag: 'div',
            position: {
                row: 1,
                cell: 0
            }
        },
        {
            id: 'releaseBtn',
            content: '',
            tag: 'div',
            position: {
                row: 1,
                cell: 1
            }
        },
        {
            id: 'seekByBtn',
            content: '',
            tag: 'div',
            position: {
                row: 2,
                cell: 0
            }
        },
        {
            id: 'seekToBtn',
            content: '',
            tag: 'div',
            position: {
                row: 2,
                cell: 1
            }
        },
        {
            id: 'seekInput',
            content: '',
            tag: 'input',
            type: 'number',
            position: {
                row: 2,
                cell: 2
            }
        },
        {
            id: 'halfSpeedBtn',
            content: '',
            tag: 'div',
            position: {
                row: 0,
                cell: 2
            }
        },
        {
            id: 'setVolumeBtn',
            content: '',
            tag: 'div',
            position: {
                row: 3,
                cell: 0
            }
        },
        {
            id: 'volumeInput',
            tag: 'input',
            type: 'text',
            position: {
                row: 3,
                cell: 1
            }
        }
    ];
    var elementsRecord = [
        {
            id: 'recordbtn',
            content: '',
            tag: 'div',
            position: {
                row: 1,
                cell: 0
            }
        },
        {
            id: 'recordplayBtn',
            content: '',
            tag: 'div',
            position: {
                row: 1,
                cell: 1
            }
        },
        {
            id: 'recordpauseBtn',
            content: '',
            tag: 'div',
            position: {
                row: 2,
                cell: 0
            }
        },
        {
            id: 'recordstopBtn',
            content: '',
            tag: 'div',
            position: {
                row: 2,
                cell: 1
            }
        }
    ];

    // Title audio results
    var div = document.createElement('h2');
    div.appendChild(document.createTextNode('Audio'));
    div.setAttribute('align', 'center');
    contentEl.appendChild(div);
    // Generate and add results table
    contentEl.appendChild(generateTable('info', 3, 3, elementsResultsAudio));

    // Title audio actions
    div = document.createElement('h2');
    div.appendChild(document.createTextNode('Actions'));
    div.setAttribute('align', 'center');
    contentEl.appendChild(div);
    // Generate and add buttons table
    contentEl.appendChild(generateTable('audioActions', 4, 3, elementsAudio));
    createActionButton(
        'Play',
        function () {
            playAudio();
        },
        'playBtn'
    );
    createActionButton(
        'Pause',
        function () {
            pauseAudio();
        },
        'pauseBtn'
    );
    createActionButton(
        'HalfSpeed',
        function () {
            if (halfSpeedBtn.firstChild.firstChild.innerText === 'HalfSpeed') {
                halfSpeedBtn.firstChild.firstChild.innerText = 'FullSpeed';
                media1.setRate(0.5);
            } else if (halfSpeedBtn.firstChild.firstChild.innerText === 'FullSpeed') {
                halfSpeedBtn.firstChild.firstChild.innerText = 'DoubleSpeed';
                media1.setRate(1.0);
            } else {
                halfSpeedBtn.firstChild.firstChild.innerText = 'HalfSpeed';
                media1.setRate(2.0);
            }
        },
        'halfSpeedBtn'
    );
    createActionButton(
        'Stop',
        function () {
            stopAudio();
        },
        'stopBtn'
    );
    createActionButton(
        'Release',
        function () {
            releaseAudio();
        },
        'releaseBtn'
    );
    createActionButton(
        'Seek By',
        function () {
            seekAudio('by');
        },
        'seekByBtn'
    );
    createActionButton(
        'Seek To',
        function () {
            seekAudio('to');
        },
        'seekToBtn'
    );
    createActionButton(
        'Set volume',
        function () {
            setVolume();
        },
        'setVolumeBtn'
    );
    // get Special path to record if iOS || Blackberry
    if (cordova.platformId === 'ios') {
        getRecordSrc();
    } else if (cordova.platformId === 'blackberry') {
        getRecordSrcBB();
    } else if (cordova.platformId === 'windows' || cordova.platformId === 'windows8') {
        getRecordSrcWin();
    }

    // testing process and details
    function addItemToList (_list, _text) {
        var item = document.createElement('li');
        item.appendChild(document.createTextNode(_text));
        _list.appendChild(item);
    }

    div = document.createElement('h4');
    div.appendChild(document.createTextNode('Recommended Test Procedure'));
    contentEl.appendChild(div);

    var list = document.createElement('ol');
    addItemToList(
        list,
        'Press play - Will start playing audio. Status: Running, Duration: 61.333 sec, Position: Current position of audio track'
    );
    addItemToList(
        list,
        'Press pause - Will pause the audio. Status: Paused, Duration: 61.333 sec, Position: Position where track was paused'
    );
    addItemToList(list, 'Press play - Will begin playing where track left off from the pause');
    addItemToList(list, 'Press stop - Will stop the audio. Status: Stopped, Duration: 61.333 sec, Position: 0 sec');
    addItemToList(list, 'Press play - Will begin playing the audio track from the beginning');
    addItemToList(list, 'Press release - Will stop the audio. Status: Stopped, Duration: 61.333 sec, Position: 0 sec');
    addItemToList(list, 'Press play - Will begin playing the audio track from the beginning');
    addItemToList(list, 'Type 10 in the text box beside Seek To button');
    addItemToList(list, 'Press seek by - Will jump 10 seconds ahead in the audio track. Position: should jump by 10 sec');
    addItemToList(list, 'Press stop if track is not already stopped');
    addItemToList(list, 'Type 30 in the text box beside Seek To button');
    addItemToList(list, 'Press play then seek to - Should jump to Position 30 sec');
    addItemToList(list, 'Press stop');
    addItemToList(list, 'Type 5 in the text box beside Seek To button');
    addItemToList(list, 'Press play, let play past 10 seconds then press seek to - should jump back to position 5 sec');

    div = document.createElement('div');
    div.setAttribute(
        'style',
        'background:#B0C4DE;border:1px solid #FFA07A;margin:15px 6px 0px;min-width:295px;max-width:97%;padding:4px 0px 2px 10px;min-height:160px;max-height:200px;overflow:auto'
    );
    div.appendChild(list);
    contentEl.appendChild(div);

    // Title Record Audio
    div = document.createElement('h2');
    div.appendChild(document.createTextNode('Record Audio'));
    div.setAttribute('align', 'center');
    contentEl.appendChild(div);
    // Generate and add Record buttons table
    contentEl.appendChild(generateTable('recordContent', 3, 3, elementsRecord));
    createActionButton(
        'Record Audio \n 10 sec',
        function () {
            recordAudio();
        },
        'recordbtn'
    );
    createActionButton(
        'Play',
        function () {
            playRecording();
        },
        'recordplayBtn'
    );
    createActionButton(
        'Pause',
        function () {
            pauseAudio();
        },
        'recordpauseBtn'
    );
    createActionButton(
        'Stop',
        function () {
            stopAudio();
        },
        'recordstopBtn'
    );

    // testing process and details
    div = document.createElement('h4');
    div.appendChild(document.createTextNode('Recommended Test Procedure'));
    contentEl.appendChild(div);

    list = document.createElement('ol');
    addItemToList(
        list,
        'Press Record Audio 10 sec - Will start recording audio for 10 seconds. Status: Running, Position: number of seconds recorded (will stop at 10)'
    );
    addItemToList(list, 'Status will change to Stopped when finished recording');
    addItemToList(
        list,
        'Press play - Will begin playing the recording. Status: Running, Duration: # of seconds of recording, Position: Current position of recording'
    );
    addItemToList(
        list,
        'Press stop - Will stop playing the recording. Status: Stopped, Duration: # of seconds of recording, Position: 0 sec'
    );
    addItemToList(list, 'Press play - Will begin playing the recording from the beginning');
    addItemToList(
        list,
        'Press pause - Will pause the playback of the recording. Status: Paused, Duration: # of seconds of recording, Position: Position where recording was paused'
    );
    addItemToList(list, 'Press play - Will begin playing the recording from where it was paused');

    div = document.createElement('div');
    div.setAttribute(
        'style',
        'background:#B0C4DE;border:1px solid #FFA07A;margin:15px 6px 0px;min-width:295px;max-width:97%;padding:4px 0px 2px 10px;min-height:160px;max-height:200px;overflow:auto'
    );
    div.appendChild(list);
    contentEl.appendChild(div);
};