/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed 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.
 */

package com.android.fmradio;

import android.app.ActionBar;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.database.Cursor;
import android.graphics.Color;
import android.graphics.PorterDuff;
import android.location.Location;
import android.location.LocationManager;
import android.media.AudioManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.text.SpannableString;
import android.text.style.ForegroundColorSpan;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.android.fmradio.FmService.OnExitListener;
import com.android.fmradio.FmStation.Station;

/**
 * This class interact with user, provider edit station information, such as add
 * to favorite, edit favorite, delete from favorite
 */
public class FmFavoriteActivity extends Activity {
    // Logging
    private static final String TAG = "FmFavoriteActivity";

    public static final String ACTIVITY_RESULT = "ACTIVITY_RESULT";

    private static final String SHOW_GPS_DIALOG = "SHOW_GPS_DIALOG";

    private static final String GPS_NOT_LOCATED_DIALOG = "GPS_NOT_LOCATED_DIALOG";

    private ListView mLvFavorites = null; // list view

    LinearLayout mSearchTips = null;

    private Context mContext = null; // application context

    private OnExitListener mExitListener = null;

    private MyFavoriteAdapter mMyAdapter;

    private ProgressBar mSearchProgress = null;

    private MenuItem mMenuRefresh = null;

    private LocationManager mLocationManager;

    private Location mCurLocation;

    private boolean mIsActivityForeground = true;

    /**
     * on create
     *
     * @param savedInstanceState The save instance state
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Bind the activity to FM audio stream.
        setVolumeControlStream(AudioManager.STREAM_MUSIC);
        getWindow().requestFeature(Window.FEATURE_ACTION_BAR);
        setContentView(R.layout.favorite);
        // display action bar and navigation button
        ActionBar actionBar = getActionBar();
        actionBar.setTitle(getString(R.string.station_title));
        actionBar.setDisplayHomeAsUpEnabled(true);
        mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        mContext = getApplicationContext();

        mMyAdapter = new MyFavoriteAdapter(mContext);
        mLvFavorites = (ListView) findViewById(R.id.station_list);
        mSearchTips = (LinearLayout) findViewById(R.id.search_tips);
        mSearchProgress = (ProgressBar) findViewById(R.id.search_progress);
        mLvFavorites.setAdapter(mMyAdapter); // set adapter
        mMyAdapter.swipResult(getData());

        mLvFavorites.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            /**
             * Click list item will finish activity and pass value to other activity
             *
             * @param parent adapter view
             * @param view item view
             * @param position current position
             * @param id current id
             */
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                // Set the selected frequency to main UI and finish the
                // favorite manager.
                TextView textView = (TextView) view.findViewById(R.id.lv_station_freq);
                float frequency = 0;
                try {
                    frequency = Float.parseFloat(textView.getText().toString());
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                }
                Intent intentResult = new Intent();
                intentResult.putExtra(ACTIVITY_RESULT, FmUtils.computeStation(frequency));
                setResult(RESULT_OK, intentResult);
                finish();
            }
        });

        // Finish favorite when exit FM
        mExitListener = new FmService.OnExitListener() {
            @Override
            public void onExit() {
                Handler mainHandler = new Handler(Looper.getMainLooper());
                mainHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        FmFavoriteActivity.this.finish();
                    }
                });
            }
        };
        FmService.registerExitListener(mExitListener);
        if (!mIsServiceBinded) {
            bindService();
        }
    }

    /**
     * When menu is selected
     *
     * @param item The selected menu item
     * @return true to consume it, false to can handle other
     */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case android.R.id.home:
                onBackPressed();
                break;
            case R.id.fm_station_list_refresh:
                if (null != mService) {
                    refreshMenuItem(false);

                    mMyAdapter.swipResult(null);
                    mLvFavorites.setEmptyView(mSearchTips);
                    mSearchProgress.setIndeterminate(true);

                    // If current location and last location exceed defined distance, delete the RDS database
                    if (isGpsOpen()) {
                        mCurLocation = mLocationManager
                                .getLastKnownLocation(LocationManager.GPS_PROVIDER);
                        if (mCurLocation != null) {
                            double[] lastLocations = FmUtils.getLastSearchedLocation(mContext);
                            float distance[] = new float[2];
                            Location.distanceBetween(lastLocations[0], lastLocations[1],
                                    mCurLocation.getLatitude(), mCurLocation.getLongitude(),
                                    distance);
                            float searchedDistance = distance[0];
                            boolean exceed =
                                    searchedDistance > FmUtils.LOCATION_DISTANCE_EXCEED;
                            mService.setDistanceExceed(exceed);
                            FmUtils.setLastSearchedLocation(mContext, mCurLocation.getLatitude(),
                                    mCurLocation.getLongitude());
                        }
                    }

                    mService.startScanAsync();
                }
                break;
            default:
                break;
        }
        return super.onOptionsItemSelected(item);
    }

    @Override
    public void onBackPressed() {
        if (null == mService) {
            Log.w(TAG, "onBackPressed, mService is null");
        } else {
            boolean isScanning = mService.isScanning();
            if (isScanning) {
                mService.stopScan();
            }
        }
        super.onBackPressed();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.fm_station_list_menu, menu);
        mMenuRefresh = menu.findItem(R.id.fm_station_list_refresh);
        resetMenuTitleColor(true);
        return true;
    }

    private void resetMenuTitleColor(boolean enabled) {
        SpannableString ss = new SpannableString(mMenuRefresh.getTitle());
        int titleColor = enabled ? getResources().getColor(R.color.actionbar_overflow_title_color)
                : getResources().getColor(R.color.actionbar_overflow_title_disabled_color);
        ss.setSpan(new ForegroundColorSpan(titleColor), 0, ss.length(), 0);
        mMenuRefresh.setTitle(ss);
    }

    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {
        if (null != mService) {
            boolean isScan = mService.isScanning();
            refreshMenuItem(!isScan);
        }
        return super.onPrepareOptionsMenu(menu);
    }

    static final class ViewHolder {
        ImageView mStationTypeView;
        TextView mStationFreqView;
        TextView mStationNameView;
        TextView mStationRdsView;
        RelativeLayout mImgLayout;
    }

    private Cursor getData() {
        Cursor cursor = mContext.getContentResolver().query(Station.CONTENT_URI,
                FmStation.COLUMNS, null, null, FmStation.Station.FREQUENCY);
        return cursor;
    }

    class MyFavoriteAdapter extends BaseAdapter {
        private Cursor mCursor;

        private LayoutInflater mInflater;

        public MyFavoriteAdapter(Context context) {
            mInflater = LayoutInflater.from(context);
        }

        public void swipResult(Cursor cursor) {
            if (null != mCursor) {
                mCursor.close();
            }
            mCursor = cursor;
            notifyDataSetChanged();
        }

        @Override
        public int getCount() {
            if (null != mCursor) {
                return mCursor.getCount();
            }
            return 0;
        }

        @Override
        public Object getItem(int position) {
            return null;
        }

        @Override
        public long getItemId(int position) {
            return 0;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            ViewHolder viewHolder = null;
            if (null == convertView) {
                viewHolder = new ViewHolder();
                convertView = mInflater.inflate(R.layout.station_item, null);
                viewHolder.mStationTypeView = (ImageView) convertView
                        .findViewById(R.id.lv_station_type);
                viewHolder.mStationFreqView = (TextView) convertView
                        .findViewById(R.id.lv_station_freq);
                viewHolder.mStationNameView = (TextView) convertView
                        .findViewById(R.id.lv_station_name);
                viewHolder.mStationRdsView = (TextView) convertView
                        .findViewById(R.id.lv_station_rds);
                viewHolder.mImgLayout = (RelativeLayout) convertView
                        .findViewById(R.id.list_item_right);
                convertView.setTag(viewHolder);
            } else {
                viewHolder = (ViewHolder) convertView.getTag();
            }

            if (mCursor != null && mCursor.moveToFirst()) {
                mCursor.moveToPosition(position);
                final int stationFreq = mCursor.getInt(mCursor
                        .getColumnIndex(FmStation.Station.FREQUENCY));
                String name = mCursor.getString(mCursor
                        .getColumnIndex(FmStation.Station.STATION_NAME));
                String rds = mCursor.getString(mCursor
                        .getColumnIndex(FmStation.Station.RADIO_TEXT));
                final int isFavorite = mCursor.getInt(mCursor
                        .getColumnIndex(FmStation.Station.IS_FAVORITE));

                if (null == name || "".equals(name)) {
                    name = mCursor.getString(mCursor
                            .getColumnIndex(FmStation.Station.PROGRAM_SERVICE));
                }

                if (rds == null || rds.equals("")) {
                    viewHolder.mStationRdsView.setVisibility(View.GONE);
                } else {
                    viewHolder.mStationRdsView.setVisibility(View.VISIBLE);
                }

                viewHolder.mStationFreqView.setText(FmUtils.formatStation(stationFreq));
                viewHolder.mStationNameView.setText(name);
                viewHolder.mStationRdsView.setText(rds);
                if (0 == isFavorite) {
                    viewHolder.mStationTypeView.setImageResource(R.drawable.btn_fm_favorite_off);
                    viewHolder.mStationTypeView.setColorFilter(Color.BLACK,
                            PorterDuff.Mode.SRC_ATOP);
                    viewHolder.mStationTypeView.setAlpha(0.54f);
                } else {
                    viewHolder.mStationTypeView.setImageResource(R.drawable.btn_fm_favorite_on);
                    viewHolder.mStationTypeView.setColorFilter(null);
                    viewHolder.mStationTypeView.setAlpha(1.0f);
                }

                viewHolder.mImgLayout.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        if (0 == isFavorite) {
                            addFavorite(stationFreq);
                        } else {
                            deleteFavorite(stationFreq);
                        }
                    }
                });
            }
            return convertView;
        }
    }

    /**
     * Add searched station as favorite station
     */
    public void addFavorite(int stationFreq) {
        // TODO it's on UI thread, change to sub thread
        // update the station name and station type in database
        // according the frequency
        FmStation.addToFavorite(mContext, stationFreq);
        mMyAdapter.swipResult(getData());
    }

    /**
     * Delete favorite from favorite station list, make it as searched station
     */
    public void deleteFavorite(int stationFreq) {
        // TODO it's on UI thread, change to sub thread
        // update the station type from favorite to searched.
        FmStation.removeFromFavorite(mContext, stationFreq);
        mMyAdapter.swipResult(getData());
    }

    @Override
    protected void onResume() {
        super.onResume();
        mIsActivityForeground = true;
        if (null != mService) {
            mService.setFmMainActivityForeground(mIsActivityForeground);
            if (FmRecorder.STATE_RECORDING != mService.getRecorderState()) {
                mService.removeNotification();
            }
        }
    }

    @Override
    protected void onPause() {
        mIsActivityForeground = false;
        if (null != mService) {
            mService.setFmMainActivityForeground(mIsActivityForeground);
        }
        super.onPause();
    }

    @Override
    protected void onStop() {
       // FmUtils.updateFrontActivity(mContext, "");
        if (null != mService) {
            // home key pressed, show notification
            mService.setNotificationClsName(FmFavoriteActivity.class.getName());
            mService.updatePlayingNotification();
        }
        super.onStop();
    }

    @Override
    protected void onDestroy() {
        mMyAdapter.swipResult(null);
        FmService.unregisterExitListener(mExitListener);
        if (mService != null) {
            mService.unregisterFmRadioListener(mFmRadioListener);
        }
        unbindService();
        super.onDestroy();
    }

    private FmService mService = null;

    private boolean mIsServiceBinded = false;

    private void bindService() {
        mIsServiceBinded = bindService(new Intent(FmFavoriteActivity.this, FmService.class),
                mServiceConnection, Context.BIND_AUTO_CREATE);
        if (!mIsServiceBinded) {
            Log.e(TAG, "bindService, mIsServiceBinded is false");
            finish();
        }
    }

    private void unbindService() {
        if (mIsServiceBinded) {
            unbindService(mServiceConnection);
        }
    }

    // Service listener
    private FmListener mFmRadioListener = new FmListener() {
        @Override
        public void onCallBack(Bundle bundle) {
            int flag = bundle.getInt(FmListener.CALLBACK_FLAG);
            if (flag == FmListener.MSGID_FM_EXIT) {
                mHandler.removeCallbacksAndMessages(null);
            }

            // remove tag message first, avoid too many same messages in queue.
            Message msg = mHandler.obtainMessage(flag);
            msg.setData(bundle);
            mHandler.removeMessages(flag);
            mHandler.sendMessage(msg);
        }
    };

    /**
     * Main thread handler to update UI
     */
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            Log.d(TAG,
                    "handleMessage, what = " + msg.what + ",hashcode:"
                            + mHandler.hashCode());
            Bundle bundle;
            switch (msg.what) {
                case FmListener.MSGID_SCAN_FINISHED:
                    bundle = msg.getData();
                    // cancel scan happen
                    boolean isScan = bundle.getBoolean(FmListener.KEY_IS_SCAN);
                    int searchedNum = bundle.getInt(FmListener.KEY_STATION_NUM);
                    refreshMenuItem(true);
                    mMyAdapter.swipResult(getData());
                    mService.updatePlayingNotification();
                    if (searchedNum == 0) {
                        Toast.makeText(mContext, getString(R.string.toast_cannot_search),
                                Toast.LENGTH_SHORT).show();
                        // searched station is zero, if db has station, should not use empty.
                        if (mMyAdapter.getCount() == 0) {
                            View emptyView = (View) findViewById(R.id.empty_tips);
                            emptyView.setVisibility(View.VISIBLE);
                            View searchTips = (View) findViewById(R.id.search_tips);
                            searchTips.setVisibility(View.GONE);
                        }
                        return;
                    }
                    // Show toast to tell user how many stations have been searched
                    String text = getString(R.string.toast_station_searched) + " "
                            + String.valueOf(searchedNum);
                    Toast.makeText(mContext, text, Toast.LENGTH_SHORT).show();
                    break;
                case FmListener.MSGID_SWITCH_ANTENNA:
                    bundle = msg.getData();
                    boolean isHeadset = bundle.getBoolean(FmListener.KEY_IS_SWITCH_ANTENNA);
                    // if receive headset plugout, need set headset mode on ui
                    if (!isHeadset) {
                        finish();
                    }
                    break;
                default:
                    break;
            }
        }
    };

    private void refreshMenuItem(boolean enabled) {
        // action menu
        if (mMenuRefresh != null) {
            mMenuRefresh.setEnabled(enabled);
            resetMenuTitleColor(enabled);
        }
    }

    // When call bind service, it will call service connect. register call back
    // listener and initial device
    private final ServiceConnection mServiceConnection = new ServiceConnection() {

        /**
         * called by system when bind service
         *
         * @param className component name
         * @param service service binder
         */
        @Override
        public void onServiceConnected(ComponentName className, IBinder service) {
            mService = ((FmService.ServiceBinder) service).getService();
            if (null == mService) {
                Log.e(TAG, "onServiceConnected, mService is null");
                finish();
                return;
            }
            mService.registerFmRadioListener(mFmRadioListener);
            mService.setFmMainActivityForeground(mIsActivityForeground);
            if (FmRecorder.STATE_RECORDING != mService.getRecorderState()) {
                mService.removeNotification();
            }
            // FmUtils.isFirstEnterStationList() must be called at the first time.
            // After it is called, it will save status to SharedPreferences.
            if (FmUtils.isFirstEnterStationList(mContext) || (0 == mMyAdapter.getCount())) {
                refreshMenuItem(false);
                mLvFavorites.setEmptyView(mSearchTips);
                mSearchProgress.setIndeterminate(true);
                mMyAdapter.swipResult(null);
                mService.startScanAsync();
            } else {
                boolean isScan = mService.isScanning();
                if (isScan) {
                    mMyAdapter.swipResult(null);
                    mLvFavorites.setEmptyView(mSearchTips);
                    mSearchProgress.setIndeterminate(true);
                } else {
                    // TODO it's on UI thread, change to sub thread
                    mMyAdapter.swipResult(getData());
                }
                refreshMenuItem(!isScan);
            }
        }

        /**
         * When unbind service will call this method
         *
         * @param className The component name
         */
        @Override
        public void onServiceDisconnected(ComponentName className) {
        }
    };

    /**
     * check gps is open or not
     *
     * @return true is open
     */
    private boolean isGpsOpen() {
        return mLocationManager.isProviderEnabled(android.location.LocationManager.GPS_PROVIDER);
    }
}