package com.sharefaith.thesharefaithapp.ui;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.graphics.PorterDuff;
import android.graphics.drawable.Drawable;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.Window;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.RelativeLayout;
import android.widget.SeekBar;
import android.widget.TextView;

import com.sharefaith.thesharefaithapp.R;
import com.sharefaith.thesharefaithapp.adapters.LimitedMapCache;
import com.sharefaith.thesharefaithapp.adapters.SFDownloadsAdapter;
import com.sharefaith.thesharefaithapp.adapters.SFNavMenuAdapter;
import com.sharefaith.thesharefaithapp.base.SFAppData;
import com.sharefaith.thesharefaithapp.base.SFApplication;
import com.sharefaith.thesharefaithapp.base.SFConfig;
import com.sharefaith.thesharefaithapp.base.SFUtil;
import com.sharefaith.thesharefaithapp.models.SFSermonModel;

import java.io.File;
import java.lang.reflect.Method;

public class SFDownloadsActivity extends Activity
{
    private SFApplication mApplication;
    private SFAppData mAppData;
    private SFConfig mConfig;
    private Handler mHandler = new Handler();

    private SFSermonModel mCurrentSermon;
    private SFSermonModel[] mSermons;
    private SFDownloadsAdapter mAdapter;

    private ListView mMainNavList;
    private ImageView mRefreshButton;
    private ImageView mOpenSettingsButton;
    private ListView mSermonsListView;
    private RelativeLayout slideRight;
    private TextView mTitleView;
    private ImageView mImage;
    private TextView mDate;
    private TextView mTextView;
    private ImageView mImageView;
    private SeekBar mSeekBar;

    private static LimitedMapCache<String, Bitmap> mBitMapCache;
    private BitmapFactory.Options mOptions;

    private GestureDetector mDetector;
    private View.OnTouchListener mGestureListener;
    private ListenButtonClickListener playListener;
    private ListenBibleButtonClickListener biblePlayListener;

    @Override
    protected void onCreate( Bundle savedInstanceState )
    {
        super.onCreate( savedInstanceState );
        this.requestWindowFeature( Window.FEATURE_NO_TITLE );
        setContentView( R.layout.sf_downloaded_base );

        //if not tablet keep screen from rotating
        if( !SFConfig.isTablet() )
        {
            setRequestedOrientation( ActivityInfo.SCREEN_ORIENTATION_PORTRAIT );
        }

        mApplication = SFApplication.getInstance();
        mAppData = new SFAppData();

        //gesture detection
        mDetector = new GestureDetector( this, new SFGestureListener() );
        mGestureListener = new View.OnTouchListener()
        {
            public boolean onTouch( View v, MotionEvent event )
            {
                return mDetector.onTouchEvent( event );
            }
        };
        SFUtil.logSiteEvent( "Opened Downloads" );

    }

    @Override
    protected void onResume()
    {
        super.onResume();

        //Google Analytics tracking
        mApplication.logScreen("sermon_downloads");

        mApplication.setCurrentActivity( this );
        mApplication.currentViewTag = "downloads";
        mApplication.currentSectionPosition = -1;

        mConfig = new SFConfig();

        mTitleView = (TextView) findViewById( R.id.title_textView );
        mImage = (ImageView) findViewById( R.id.imageView );
        mDate = (TextView) findViewById( R.id.date_textView );

        mSermonsListView = (ListView) findViewById( R.id.listView );
        mSermons = SFSermonModel.getDownloadedSermons( true );
        mAdapter = new SFDownloadsAdapter( mApplication, mSermons );
        mSermonsListView.setAdapter( mAdapter );

        if(mApplication.isSermonPlaying)
        {
            mApplication.stopUpdateTicker = false;
            SFSharedUIMethods.startElapseTimer();
        }

        slideRight = (RelativeLayout) findViewById( R.id.slide_right );
        loadInterface();

        slideRight.setOnTouchListener( mGestureListener );
        mSermonsListView.setOnTouchListener( mGestureListener );

        if( mApplication.getNowPlayingSermon() != null )
        {
            mCurrentSermon = mApplication.getNowPlayingSermon();
            setupTitle();
            setupPlayControls( mCurrentSermon );
            mSermonsListView.invalidate();
        }
        else if( mApplication.isBiblePlaying )
        {
            setupTitle();
            setupPlayControls( null );
        }
        mApplication.didResume(mConfig);
    }

    /**
     * change sermons
     * @param position
     */
    public void changeSermon(int position)
    {
        //Log.d("mTag","List Item Clicked");
        mCurrentSermon = mApplication.getSfCurrentSermon();

        if (position != mApplication.OpenDownloadSermon)
        {
            mApplication.OpenDownloadSermon = position;
            mAdapter.notifyDataSetChanged();
        }
    }

    /**
     * update the UI after sermon changed
     */
    public void notifySermonChange()
    {
        mCurrentSermon = mApplication.getSfCurrentSermon();
        setupTitle();

        SFUtil.logSiteEvent( "Pause audio" );
        if(mApplication.isSermonPlaying)
        {
            int showSeconds = mApplication.getSfMediaPlayer().getCurrentPosition();
            showSeconds = showSeconds / 1000;
            mApplication.getNowPlayingSermon().saveAudioPlayProgress( showSeconds );
            mApplication.stopUpdateTicker = true;
            mApplication.releaseMediaPlayer();
        }

        mApplication.setNowPlayingSermon( mCurrentSermon );
        setupPlayControls( mCurrentSermon );
        mSermons = SFSermonModel.getDownloadedSermons( true );
        mApplication.OpenDownloadSermon = 0;
        mAdapter = new SFDownloadsAdapter( mApplication, mSermons );
        mSermonsListView.setAdapter( mAdapter );
    }

    /**
     * setup the top title layout
     */
    public void setupTitle()
    {
        //set content of header

        if(mApplication.isBiblePlaying)
        {
            String showTitle = mApplication.getCurrentBook().mFullname + ", " + (mApplication.audioChapterIndex+1);
            if( mTitleView != null )
            {
                mTitleView.setText( showTitle );
            }
        }
        else
        {
            //Log.d("mTag","Hit setup title bible not playing" );

            mCurrentSermon = mApplication.getSfCurrentSermon();
            File currentThumbnail = new File( mConfig.mCustomAssetPath + mCurrentSermon.mSeries.mThumbnail );

            //int memMB = ((ActivityManager) mApplication.getSystemService( Context.ACTIVITY_SERVICE )).getMemoryClass();
            //mBitMapCache = new LimitedMapCache<String, Bitmap>( memMB / 2 );
            mOptions = SFUtil.commonImgOpt();

            if (mCurrentSermon != null) //Set the variable things, title and excerpt, even if not creating.
            {
                //Log.d("mTag","Hit setup title currentsermon not null" );
                //Log.d("mTag","Hit setup title current sermon series thumbnail = " + mCurrentSermon.mSeries.mThumbnail );

                if( mAppData.getTitlesEnabledByPlaylistId( mCurrentSermon.mSeries.mId ) == true )
                {
                    //Log.d("mtag","hit title enabled");
                    String showTitle = SFUtil.stripHtml( mCurrentSermon.mTitle ).toString();
                    if (mTitleView != null)
                    {
                        //Log.d("mTag","Hit setup title set title" );
                        mTitleView.setText( showTitle );
                        mTitleView.setVisibility( View.VISIBLE );
                    }
                }
                else
                {
                    //Log.d( "mtag","hit title disabled" );
                    mTitleView.setVisibility( View.GONE );
                }

                if (mCurrentSermon.mSeries.mThumbnail.length() > 0 && currentThumbnail.exists())//  && !currentThumbnail.equals(holder.imgFile) )
                {
                    //Log.d("mTag","Hit setup title set image" );
                    String fileStr = currentThumbnail.getAbsolutePath();
                    //Log.d("mTag","file String = " + fileStr );
                    Bitmap bitmap = BitmapFactory.decodeFile( fileStr, SFUtil.commonImgOpt() );
                    mImage.setImageBitmap( bitmap );
                    mDate.setVisibility( View.INVISIBLE );
                }
            }
            //mTitleView.invalidate();
        }
    }

    /**
     * setup the audio buttons
     * @param sermon
     */
    public void setupPlayControls(SFSermonModel sermon)
    {
        //Log.d( "mTag","Hit setup Play controls" );
        mTextView = (TextView) findViewById( R.id.elapse_textView );
        mImageView = (ImageView) findViewById( R.id.sermonPlayImageView );
        mSeekBar = (SeekBar) findViewById( R.id.seekBar );
        Drawable rectangle = mApplication.getResources().getDrawable( R.drawable.borderbox_rounded );

        rectangle.setColorFilter( Color.parseColor( "#" + mConfig.mNavColor ), PorterDuff.Mode.MULTIPLY );
        // Using deprecated method to support Android builds 14-15
        try
        {
            Method setBackground = View.class.getMethod( "setBackground", Drawable.class );
            setBackground.invoke( mImageView, rectangle );
        }
        catch( Exception e )
        {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN)
            {
                mImageView.setBackground( rectangle );
            }
            else
            {
                mImageView.setBackgroundDrawable( rectangle );
            }
        }
        mImageView.setOnClickListener( null );

        if( sermon != null )
        {
            //Log.d( "mTag","sermon not null" );
            playListener = new ListenButtonClickListener( sermon, mImageView);
            mImageView.setOnClickListener( playListener );

            if( mApplication.isSermonPlaying)
            {
                if(mApplication.isSermonPaused)
                {
                    mImageView.setImageResource( R.drawable.audio_play );
                }
                else
                {
                    mImageView.setImageResource( R.drawable.audio_stop );
                }
            }
            else
            {
                mImageView.setImageResource( R.drawable.audio_play );
            }

            //mSeekBar = (SeekBar) findViewById( R.id.seekBar );
            mSeekBar.setMax( mApplication.getSfMediaPlayer().getDuration()/1000 );
            //Log.d( "mTag", " max = " + mApplication.getSfMediaPlayer().getDuration() / 1000 );
            mSeekBar.setProgress( sermon.mCurrentAudioProgress );
            //Log.d( "mTag","current audio progress = " + sermon.mCurrentAudioProgress);
            mSeekBar.setOnSeekBarChangeListener( new SeekBar.OnSeekBarChangeListener()
            {
                @Override
                public void onProgressChanged( SeekBar seekBar, int progress, boolean fromUser )
                {
                    if(fromUser)
                    {
                        mApplication.getSfMediaPlayer().seekTo( progress*1000 );
                    }
                }

                @Override
                public void onStartTrackingTouch( SeekBar seekBar )
                {
                    //Auto-generated
                }

                @Override
                public void onStopTrackingTouch( SeekBar seekBar )
                {

                }
            } );
            mTextView.setText( mApplication.secondsToElapseString( sermon.mCurrentAudioProgress ) );
        }
        else if( mApplication.isBiblePlaying)
        {
            //Log.d( "mTag","Bible playing" );
            //Log.d("mTag","hit setupPlayControls isBiblePlayint ");
            biblePlayListener = new ListenBibleButtonClickListener( mImageView );
            mImageView.setOnClickListener( biblePlayListener );


            if(mApplication.isBibleAudioPaused)
            {
                mImageView.setImageResource( R.drawable.audio_play );
            }
            else
            {
                mImageView.setImageResource( R.drawable.audio_pause );
            }


            mSeekBar.setMax( mApplication.getSfMediaPlayer().getDuration() / 1000 );
            //Log.d( "mTag", "seekbar max = " + mSeekBar.getMax() );
            mSeekBar.setProgress( mApplication.getSfMediaPlayer().getCurrentPosition()/1000 );
            mSeekBar.setOnSeekBarChangeListener( new SeekBar.OnSeekBarChangeListener()
            {
                @Override
                public void onProgressChanged( SeekBar seekBar, int progress, boolean fromUser )
                {
                    if(fromUser)
                    {
                        mApplication.getSfMediaPlayer().seekTo( progress*1000 );
                    }
                }

                @Override
                public void onStartTrackingTouch( SeekBar seekBar )
                {
                    //Auto-generated
                }

                @Override
                public void onStopTrackingTouch( SeekBar seekBar )
                {

                }
            } );
            mTextView.setText( mApplication.secondsToElapseString( mApplication.getSfMediaPlayer().getCurrentPosition()/1000 ) );
        }

        else
        {
            //Log.d( "mTag","Hit no Bible no sermon" );
            mSeekBar.setProgress( 0 );
        }
        //RelativeLayout playControls = (RelativeLayout) findViewById( R.id.play_controls );
        //playControls.invalidate();
        //playControls.requestLayout();
    }

    /**
     * update the seekbar
     */
    public void refreshSeekbar()
    {
        mSeekBar.setMax( mApplication.getSfMediaPlayer().getDuration() / 1000 );
        mSeekBar.setProgress( mApplication.getSfCurrentSermon().mCurrentAudioProgress );
        mSeekBar.setOnSeekBarChangeListener( new SeekBar.OnSeekBarChangeListener()
        {
            @Override
            public void onProgressChanged( SeekBar seekBar, int progress, boolean fromUser )
            {
                if(fromUser)
                {
                    mApplication.getSfMediaPlayer().seekTo( progress*1000 );
                }
            }

            @Override
            public void onStartTrackingTouch( SeekBar seekBar )
            {
                //Auto-generated
            }

            @Override
            public void onStopTrackingTouch( SeekBar seekBar )
            {

            }
        } );
    }

    @Override
    public void onPause()
    {
        super.onPause();
        this.finish();
    }

    @Override
    public void onBackPressed()
    {
        if(mApplication.isDoingFullSync)
        {
            mApplication.makeToast( "Please wait for sync to finish" );
            return;
        }
        if (mApplication.isNavOpen)
        {
            SFSharedUIMethods.closeMenu();
            return;
        }
        this.finish();
        overridePendingTransition( R.anim.sf_activity_slidein_left, R.anim.sf_activity_slideout_right );
    }

    /**
     * OnClickListener for the navigation bar
     * @param action
     * @return
     */
    private View.OnClickListener navItemListener( final String action )
    {
        return
                new View.OnClickListener()
                {
                    public void onClick( View v )
                    {
                        if( action.equals( "opennav" ) )
                        {
                            if( !mApplication.isNavOpen )
                            {
                                SFSharedUIMethods.openMenu();
                            }
                            else
                            {
                                SFSharedUIMethods.closeMenu();
                            }

                        } // if( action.equals( "opennav" ) )
                        if( action.equals( "listennav" ) )
                        {

                            if( mApplication.isNavOpen )
                            {
                                SFSharedUIMethods.closeMenu();
                            }

                            finish();
                            overridePendingTransition( R.anim.sf_activity_slidein_left, R.anim.sf_activity_slideout_right );
                        } // if( action.equals( "opennav" ) )
                    }
                };
    }

    /**
     * Load the UI elements
     */
    private void loadInterface()
    {
        SFConfig config = new SFConfig();
        // Get the basic layout components going
        LinearLayout titleBarLayout = (LinearLayout) findViewById( R.id.navMenuContainer );
        titleBarLayout.setBackgroundColor( Color.parseColor( "#" + config.mNavColor ) );

        // Set the title bar properties
        TextView titleBarView = (TextView) findViewById( R.id.navMenuTitle );
        //titleBarView.setTypeface( SFTypeFaceSpan.getAssetTypeface( mApplication.getResources().getString( R.string.font_bold ) ) );
        titleBarView.setText( config.mAppTitle );

        ImageButton openNav = (ImageButton) findViewById( R.id.openMenuImageButton );
        openNav.setOnClickListener( this.navItemListener( "opennav" ) );

        ImageButton listenNav = (ImageButton) findViewById( R.id.openListenImageButton );
        listenNav.setOnClickListener( this.navItemListener( "listennav" ) );

        // create the main navigation menu items
        this.mMainNavList = (ListView) findViewById( R.id.mainNavListView );
        SFNavMenuAdapter navMenuAdapter = SFApplication.getInstance().getSfNavMenuAdapter();
        this.mMainNavList.setOnItemClickListener( navMenuAdapter.handleTap( this ) );
        this.mMainNavList.setAdapter( mApplication.getSfNavMenuAdapter() );

        layoutSetup();

        mRefreshButton = (ImageView) findViewById( R.id.refreshArrows );
        int iconColor = Color.parseColor( "#" + this.mConfig.customFontColorForNavColor() );
        mRefreshButton.setColorFilter( iconColor, PorterDuff.Mode.MULTIPLY );
        mRefreshButton.setOnTouchListener(new View.OnTouchListener() {
            long then = 0;
            @Override
            public boolean onTouch(View v, MotionEvent event)
            {
                if(event.getAction() == MotionEvent.ACTION_DOWN)
                {
                    this.then = System.currentTimeMillis();
                    return true;
                }
                else if(event.getAction() == MotionEvent.ACTION_UP)
                {
                    if((System.currentTimeMillis() - this.then) > 5000)
                    {
                        SFSharedUIMethods.fullrefresh();
                    }
                    else
                    {
                        SFSharedUIMethods.refresh();
                    }
                }
                return false;
            }
        });

        //Setup the settings button on menu footer
        mOpenSettingsButton = (ImageView) findViewById( R.id.openSettingsButton );
        mOpenSettingsButton.setColorFilter( iconColor, PorterDuff.Mode.MULTIPLY );
        mOpenSettingsButton.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick( View v )
            {
                SFSharedUIMethods.closeMenu();
                Intent intent = new Intent( mApplication, SFSettingsActivity.class );
                startActivity( intent );
                overridePendingTransition( R.anim.sf_activity_slidein_right, R.anim.sf_activity_slideout_left );
            }
        });

        if(mApplication.isSyncing)
        {
            SFSharedUIMethods.animateRefresh();
        }
    }

    private void layoutSetup()
    {
        ImageButton button = (ImageButton) findViewById( R.id.openMenuImageButton );
        button.setBackgroundResource( R.drawable.openmenu );
    }

    /**
     * Handles gesture touch events
     * @param event
     * @return
     */
    @Override
    public boolean onTouchEvent( MotionEvent event )
    {
        this.mDetector.onTouchEvent( event );
        return super.onTouchEvent( event );
    }

    /**
     * updates the elapse time
     */
    public Runnable mUpdateElapse = new Runnable()
    {
        public void run()
        {
            int currentDuration = mApplication.getSfMediaPlayer().getCurrentPosition();

            if( mApplication.stopUpdateTicker||mApplication.currentViewTag != "downloads")
            {
                mApplication.stopUpdateTicker = false;
                mHandler.removeCallbacks( this );
                return;
            }
            int currentSeconds = currentDuration/1000;

            mTextView.setText( mApplication.secondsToElapseString( currentSeconds ) );

            // Running this thread after 500 milliseconds
            mHandler.postDelayed( this, 500 );
        }
    };

    /**
     * start playing the sermon
     * @param sermon
     */
    public void playOnListen(SFSermonModel sermon)
    {
        playListener.startPlaying( sermon );
        playListener.setPlayButton( "stop" );
    }

    /**
     * listener for Bible chapter
     */
    public class ListenBibleButtonClickListener implements View.OnClickListener
    {
        SFApplication mApplication = SFApplication.getInstance();

        ImageView mTrigger;
        SFConfig mConfig;
        Handler mListenerHandler = new Handler();
        boolean mHadError = false;

        /**
         * set listener for Bible chapter
         * @param whichTrigger
         */
        public ListenBibleButtonClickListener( ImageView whichTrigger )
        {
            this.mTrigger = whichTrigger;
            this.mConfig = new SFConfig();
        }

        /**
         *
         * @param v
         */
        @Override
        public void onClick( View v )
        {
            try {
                // Bible is playing
                if ( mApplication.isBiblePlaying )
                {
                    // nothing was currently playing, so start playing
                    if (mApplication.isBiblePlaying && mApplication.isBibleAudioPaused)
                    {
                        mApplication.logEvent( "bible_audio","play" );
                        //Log.d( "mTag", "HIT 1 *********" );
                        this.resumePlaying();
                        if (!this.mHadError)
                        {
                            this.setPlayButton( "pause" );
                        }
                        this.mHadError = false;
                    }

                    else if ( mApplication.isBiblePlaying && !mApplication.isBibleAudioPaused )
                    {
                        mApplication.logEvent( "bible_audio","pause" );
                        //Log.d( "mTag", "HIT 1.1 *********" );
                        this.pausePlaying();
                        if (!this.mHadError)
                        {
                            this.setPlayButton( "play" );
                        }
                        this.mHadError = false;
                    }
                }

            } // try

            catch (Exception e) {
                this.mHadError = true;
                String message = mApplication.getString( R.string.file_error) + e.getLocalizedMessage();
                mApplication.makeToast( message );
                if ( mApplication.getSfMediaPlayer()!=null )
                {
                    this.stopPlaying();
                }
            }
        }// onClick

        public void stopPlaying()
        {
            SFUtil.logSiteEvent( "Pause audio" );
            mApplication.isBiblePlaying = false;
            mApplication.isBibleAudioPaused = false;
            mApplication.releaseMediaPlayer();
        }

        public void pausePlaying()
        {
            SFUtil.logSiteEvent( "Pause audio" );
            mApplication.isBibleAudioPaused = true;
            mApplication.pauseMediaPlayer();
        }

        public void resumePlaying()
        {
            mApplication.isBibleAudioPaused = false;
            mApplication.startMediaPlayer();
        }

        public void setPlayButton( String state )
        {

            int imageId = mApplication.getResources().getIdentifier( "audio_" + state, "drawable", mApplication.getPackageName() );
            mImageView.setImageResource( imageId );
        }

        public void updateProgressBar()
        {
            if( mApplication.totalDuration < 1 )
            {
                mApplication.totalDuration = mApplication.durationFromRemote( mApplication.getNowPlayingSermon() );
            }
            //mListenerHandler.postDelayed( mUpdateTimeTask, 2000 );
            SFSharedUIMethods.startElapseTimer();
            SFDownloadsActivity activity = (SFDownloadsActivity) mApplication.getCurrentActivity();
            mApplication.stopUpdateTicker = false;
            activity.mHandler.postDelayed( mUpdateElapse, 1000 );
        }
    }

    /**
     * prompt when deleting downloaded sermon
     * @param position
     */
    public void deleteSermonOverlay( final int position )
    {
        final AlertDialog.Builder builder = new AlertDialog.Builder( this );

        builder.setMessage( mApplication.getString( R.string.alert_confirm_delete_message ) );
        builder.setNegativeButton( mApplication.getString( R.string.alert_no ), null );
        builder.setPositiveButton( mApplication.getString( R.string.alert_yes ), new DialogInterface.OnClickListener()
        {
            public void onClick( DialogInterface dialog, int id )
            {
                deleteSermon(position);
            }
        });
        builder.show();
    }

    /**
     * delete the sermon at index
     * @param position
     */
    private void deleteSermon( int position )
    {
        SFSermonModel sermon =  mSermons[position];
        sermon.removeDownload();
        mSermons = SFSermonModel.getDownloadedSermons( true );
        mAdapter = new SFDownloadsAdapter( mApplication, mSermons );
        mSermonsListView.setAdapter( mAdapter );
        //mApplication.makeToast( "delete sermon " + position );

    }

    /**
     * listener for sermon buttons
     */
    public class ListenButtonClickListener implements View.OnClickListener
    {
        SFApplication mApplication = SFApplication.getInstance();

        SFSermonModel mSermon;
        ImageView mTrigger;
        SFConfig mConfig;
        Handler mListenerHandler = new Handler();
        boolean mHadError = false;

        /**
         * set Listener for sermon buttons
         * @param whichSermon
         * @param whichTrigger
         */
        public ListenButtonClickListener( SFSermonModel whichSermon, ImageView whichTrigger )
        {
            this.mSermon = whichSermon;
            this.mTrigger = whichTrigger;
            this.mConfig = new SFConfig();
        }

        @Override
        public void onClick( View v )
        {
            if(mApplication.getNowPlayingSermon() == null )
            {
                mApplication.makeToast( "Please select a sermon to play" );
                return;
            }
            try {
                // Nothing is playing, or the selected sermon is already playing
                if ( mApplication.getNowPlayingSermon().mId == this.mSermon.mId)
                {
                    // nothing was currently playing, so start playing
                    if (!mApplication.isSermonPlaying)
                    {
                        //Log.d( "mTag", "HIT 1 *********" );
                        this.startPlaying( this.mSermon );
                        if (!this.mHadError)
                        {
                            this.setPlayButton( "stop" );
                        }

                        this.mHadError = false;

                    }
                    else if(mApplication.isSermonPaused)
                    {
                        //Log.d( "mTag", "HIT 1.1 *********" );
                        mApplication.isSermonPaused = false;
                        this.resumePlaying();
                        if (!this.mHadError)
                        {
                            this.setPlayButton("stop");
                        }

                        this.mHadError = false;
                    }
                    else // or else stop it
                    {
                        //Log.d("mTag", "HIT 2 *********");
                        this.stopPlaying();
                        if (!this.mHadError) {
                            this.setPlayButton( "play" );
                        }
                        this.mHadError = false;
                    }
                } else // something is set as "Now Playing" and it wasn't the one tapped
                {

                    // Nothing is currently playing, so start the one that was tapped
                    if (!mApplication.isSermonPlaying) {
                        //Log.d("mTag", "HIT 3 *********");
                        this.startPlaying(this.mSermon);
                        if (!this.mHadError) {
                            this.setPlayButton( "stop" );
                        }
                        this.mHadError = false;
                    } else // something was playing. stop it
                    {
                        //Log.d("mTag", "HIT 4 *********");
                        this.stopPlaying();

                        // and presumably, we are going to be starting something new
                        if (mApplication.getNowPlayingSermon().mId != this.mSermon.mId) {
                            //Log.d("mTag", "HIT 5 *********");
                            this.startPlaying(this.mSermon);
                            if (!this.mHadError) {
                                this.setPlayButton( "stop" );
                            }
                            this.mHadError = false;
                        }
                    }
                } // else // something is set as "Now Playing"...

            } // try

            catch (Exception e) {
                this.mHadError = true;
                String message = mApplication.getString( R.string.file_error) + e.getLocalizedMessage();
                mApplication.makeToast( message );
                if ( mApplication.getSfMediaPlayer()!=null )
                {
                    this.stopPlaying();
                }
            }
        }// onClick

        public void startPlaying( SFSermonModel sermon )
        {
            this.startPlaying( sermon, false );
        }

        public void startPlaying( SFSermonModel sermon, boolean forceRemote )
        {
            SFUtil.logSiteEvent( "Play audio" );

            mApplication.setNowPlayingSermon( sermon );
            if(mApplication.isBiblePlaying)
            {
                mApplication.isBiblePlaying = false;
                mApplication.isBibleAudioPaused = false;
                mApplication.releaseMediaPlayer();
            }

            //request audio focus from AudioManager
            if( !mApplication.haveAudioFocus ) {
                int result = mApplication.getSfAudioManager().requestAudioFocus(mApplication.getSfOnAudioFocusChangeListener(), AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
                if ( result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED )
                {
                    mApplication.haveAudioFocus = true;
                }
            }

            this.mSermon.refreshMembers();
            boolean mediaIsLocal = false;
            String playableSource = sermon.mAudioUrl;
            if( sermon.mAudioLocation.length() > 0 && !forceRemote )
            {
                playableSource = this.mConfig.mMediaAssetPath + sermon.mAudioLocation;
                mediaIsLocal = true;
            }

            if( mApplication.getSfMediaPlayer() == null )
            {
                mApplication.getSfMediaPlayer();
                final ListenButtonClickListener listener = this;
                mApplication.getSfMediaPlayer().setOnCompletionListener( new MediaPlayer.OnCompletionListener()
                {
                    @Override
                    public void onCompletion( MediaPlayer mediaPlayer )
                    {
                        mApplication.getNowPlayingSermon().saveAudioPlayProgress( 0 );
                        mApplication.getNowPlayingSermon().refreshMembers();
                        listener.setPlayButton( "play" );
                        listener.stopPlaying();
                    }
                } );
            }

            try
            {
                this.mSermon.setNowPlaying();
                mApplication.setNowPlayingSermon( this.mSermon );

                mApplication.getSfMediaPlayer().setDataSource( playableSource );
                final boolean mediaIsLocalFinal = mediaIsLocal;
                mApplication.getSfMediaPlayer().prepareAsync();
                mApplication.getSfMediaPlayer().setOnPreparedListener( new MediaPlayer.OnPreparedListener()
                {
                    @Override
                    public void onPrepared( MediaPlayer mp )
                    {
                        mApplication.isAudioPreped = true;
                        if (mediaIsLocalFinal || mApplication.getSfMediaPlayer().getDuration() > 0)
                        {
                            mApplication.totalDuration = mApplication.getSfMediaPlayer().getDuration();
                        }
                        mApplication.getSfMediaPlayer().seekTo( mApplication.getNowPlayingSermon().mCurrentAudioProgress * 1000 );
                        mApplication.startMediaPlayer();
                        mApplication.isSermonPlaying = true;
                        mApplication.isSermonPaused = false;
                        SFSharedUIMethods.startElapseTimer();
                        refreshSeekbar();
                        //updateProgressBar();
                    }
                } );



                if( mApplication.currentViewTag != "downloads" )
                {
                    //mainActivity.reloadDownloadsScreen();
                }
            }
            catch( Exception e )
            {
                // Some older APIs would refuse to play most local MP3 files, but the remote version works just fine
                if( mediaIsLocal && !forceRemote )
                {
                    this.startPlaying( sermon, true );
                }
                else
                {
                    this.mHadError = true;
                    String message = mApplication.getString( R.string.file_error ) + e.getLocalizedMessage();
                    mApplication.makeToast( message );
                    this.stopPlaying();
                }
            }
        }

        public void stopPlaying()
        {
            SFUtil.logSiteEvent( "Pause audio" );
            mApplication.releaseMediaPlayer();
        }

        public void pausePlaying()
        {
            SFUtil.logSiteEvent( "Pause audio" );
            mApplication.pauseMediaPlayer();
        }

        public void resumePlaying()
        {
            mApplication.startMediaPlayer();
            mApplication.getNowPlayingSermon().refreshMembers();
        }

        public void setPlayButton( String state )
        {

            int imageId = mApplication.getResources().getIdentifier( "audio_" + state, "drawable", mApplication.getPackageName() );
            mImageView.setImageResource( imageId );
        }

        public void hidePlayButton(TextView childView)
        {
            RelativeLayout parentView = (RelativeLayout) childView.getParent();
            ImageView playImageView = (ImageView) parentView.findViewById( R.id.sermonPlayImageView );
            playImageView.setVisibility( View.INVISIBLE );
        }

        public void updateProgressBar()
        {
            if( mApplication.totalDuration < 1 )
            {
                mApplication.totalDuration = mApplication.durationFromRemote( mApplication.getNowPlayingSermon() );
            }
            //mListenerHandler.postDelayed( mUpdateTimeTask, 2000 );
            SFSharedUIMethods.startElapseTimer();
            SFDownloadsActivity activity = (SFDownloadsActivity) mApplication.getCurrentActivity();
            mApplication.stopUpdateTicker = false;
            activity.mHandler.postDelayed( mUpdateElapse, 1000 );
        }



    }

    @Override
    public boolean dispatchTouchEvent( MotionEvent e )
    {
        if(mApplication.isDoingFullSync)
        {
            return true;
        }
        else
        {
            super.dispatchTouchEvent( e );
        }
        return false;
    }
}
