package org.wordpress.android.ui;

import android.content.Context;
import android.support.annotation.MenuRes;
import android.support.design.widget.AppBarLayout;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.Toolbar;
import android.util.AttributeSet;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.ProgressBar;
import android.widget.RelativeLayout;
import android.widget.Spinner;
import android.widget.TextView;

import org.wordpress.android.R;
import org.wordpress.android.models.FilterCriteria;
import org.wordpress.android.util.AppLog;
import org.wordpress.android.util.DisplayUtils;
import org.wordpress.android.util.NetworkUtils;
import org.wordpress.android.util.helpers.SwipeToRefreshHelper;
import org.wordpress.android.util.widgets.CustomSwipeRefreshLayout;
import org.wordpress.android.widgets.RecyclerItemDecoration;

import java.util.ArrayList;
import java.util.List;


public class FilteredRecyclerView extends RelativeLayout {

    private ProgressBar mProgressLoadMore;
    private SwipeToRefreshHelper mSwipeToRefreshHelper;
    private Spinner mSpinner;
    private boolean mSelectingRememberedFilterOnCreate = false;

    private RecyclerView mRecyclerView;
    private TextView mEmptyView;
    private View mCustomEmptyView;
    private Toolbar mToolbar;
    private AppBarLayout mAppBarLayout;

    private List<FilterCriteria> mFilterCriteriaOptions;
    private FilterCriteria mCurrentFilter;
    private FilterListener mFilterListener;
    private SpinnerAdapter mSpinnerAdapter;
    private RecyclerView.Adapter<RecyclerView.ViewHolder> mAdapter;
    private int mSpinnerTextColor;
    private int mSpinnerDrawableRight;
    private AppLog.T mTAG;

    public FilteredRecyclerView(Context context) {
        super(context);
        init();
    }

    public FilteredRecyclerView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public FilteredRecyclerView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    public void setRefreshing(boolean refreshing) {
        mSwipeToRefreshHelper.setRefreshing(refreshing);
    }

    public boolean isRefreshing(){
        return mSwipeToRefreshHelper.isRefreshing();
    }

    public void setCurrentFilter(FilterCriteria filter) {
        mCurrentFilter = filter;
        int position = mSpinnerAdapter.getIndexOfCriteria(filter);
        if (position > -1 && position != mSpinner.getSelectedItemPosition()) {
            mSpinner.setSelection(position);
        }
    }

    public FilterCriteria getCurrentFilter() {
        return mCurrentFilter;
    }

    public void setFilterListener(FilterListener filterListener){
        mFilterListener = filterListener;
        setup(false);
    }

    public void setAdapter(RecyclerView.Adapter<RecyclerView.ViewHolder> adapter){
        mAdapter = adapter;
        mRecyclerView.setAdapter(mAdapter);
    }

    public RecyclerView.Adapter<RecyclerView.ViewHolder> getAdapter(){
        return mAdapter;
    }

    public void setSwipeToRefreshEnabled(boolean enable){
        mSwipeToRefreshHelper.setEnabled(enable);
    }

    public void setLogT(AppLog.T tag){
        mTAG = tag;
    }

    public void setCustomEmptyView(View v){
        mCustomEmptyView = v;
    }

    private void init() {
        inflate(getContext(), R.layout.filtered_list_component, this);

        int spacingHorizontal = 0;
        int spacingVertical = DisplayUtils.dpToPx(getContext(), 1);
        mRecyclerView = (RecyclerView) findViewById(R.id.recycler_view);
        mRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
        mRecyclerView.addItemDecoration(new RecyclerItemDecoration(spacingHorizontal, spacingVertical));

        mToolbar = (Toolbar) findViewById(R.id.toolbar_with_spinner);
        mAppBarLayout = (AppBarLayout) findViewById(R.id.app_bar_layout);

        mEmptyView = (TextView) findViewById(R.id.empty_view);

        // progress bar that appears when loading more items
        mProgressLoadMore = (ProgressBar) findViewById(R.id.progress_loading);
        mProgressLoadMore.setVisibility(View.GONE);

        mSwipeToRefreshHelper = new SwipeToRefreshHelper(getContext(),
                (CustomSwipeRefreshLayout) findViewById(R.id.ptr_layout),
                new SwipeToRefreshHelper.RefreshListener() {
                    @Override
                    public void onRefreshStarted() {
                        post(new Runnable() {
                            @Override
                            public void run() {
                                if (!NetworkUtils.checkConnection(getContext())) {
                                    mSwipeToRefreshHelper.setRefreshing(false);
                                    updateEmptyView(EmptyViewMessageType.NETWORK_ERROR);
                                    return;
                                }
                                if (mFilterListener != null){
                                    mFilterListener.onLoadData();
                                }
                            }
                        });
                    }
                });


        if (mSpinner == null) {
            mSpinner = (Spinner) findViewById(R.id.filter_spinner);
        }

    }

    private void setup(boolean refresh){
        List<FilterCriteria> criterias = mFilterListener.onLoadFilterCriteriaOptions(refresh);
        if (criterias != null){
            mFilterCriteriaOptions = criterias;
        }
        if (criterias == null){
            mFilterListener.onLoadFilterCriteriaOptionsAsync(new FilterCriteriaAsyncLoaderListener() {
                @Override
                public void onFilterCriteriasLoaded(List<FilterCriteria> criteriaList) {
                    if (criteriaList != null) {
                        mFilterCriteriaOptions = new ArrayList<FilterCriteria>();
                        mFilterCriteriaOptions.addAll(criteriaList);
                        initSpinnerAdapter();
                        setCurrentFilter(mFilterListener.onRecallSelection());
                    }
                }
            }, refresh);
        } else {
            initSpinnerAdapter();
            setCurrentFilter(mFilterListener.onRecallSelection());
        }
    }

    private void initSpinnerAdapter(){
        mSpinnerAdapter = new SpinnerAdapter(getContext(), mFilterCriteriaOptions);

        mSelectingRememberedFilterOnCreate = true;
        mSpinner.setAdapter(mSpinnerAdapter);
        mSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
            @Override
            public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
                if (mSelectingRememberedFilterOnCreate) {
                    mSelectingRememberedFilterOnCreate = false;
                    return;
                }

                FilterCriteria selectedCriteria =
                        (FilterCriteria) mSpinnerAdapter.getItem(position);

                if (mCurrentFilter == selectedCriteria) {
                    AppLog.d(mTAG, "The selected STATUS is already active: " +
                            selectedCriteria.getLabel());
                    return;
                }

                AppLog.d(mTAG, "NEW STATUS : " + selectedCriteria.getLabel());
                setCurrentFilter(selectedCriteria);
                if (mFilterListener != null) {
                    mFilterListener.onFilterSelected(position, selectedCriteria);
                    setRefreshing(true);
                    mFilterListener.onLoadData();
                }
            }

            @Override
            public void onNothingSelected(AdapterView<?> parent) {
                // nop
            }
        });

    }

    private boolean hasAdapter() {
        return (mAdapter != null);
    }

    public boolean emptyViewIsVisible(){
        return (mEmptyView != null && mEmptyView.getVisibility() == View.VISIBLE);
    }

    public void hideEmptyView() {
        if (mEmptyView != null) {
            mEmptyView.setVisibility(View.GONE);
        }
    }

    public void updateEmptyView(EmptyViewMessageType emptyViewMessageType) {
        if (mEmptyView == null) return;

        if ((hasAdapter() && mAdapter.getItemCount() == 0) || !hasAdapter()) {
            if (mFilterListener != null){
                if (mCustomEmptyView == null){
                    String msg = mFilterListener.onShowEmptyViewMessage(emptyViewMessageType);
                    if (msg == null){
                        msg = getContext().getString(R.string.empty_list_default);
                    }
                    mEmptyView.setText(msg);
                    mEmptyView.setVisibility(View.VISIBLE);
                }
                else {
                    mEmptyView.setVisibility(View.GONE);
                    mFilterListener.onShowCustomEmptyView(emptyViewMessageType);
                }
            }

        } else {
            mEmptyView.setVisibility(View.GONE);
        }
    }

    /**
     * show/hide progress bar which appears at the bottom when loading more items
     */
    public void showLoadingProgress() {
        if (mProgressLoadMore != null) {
            mProgressLoadMore.setVisibility(View.VISIBLE);
        }
    }

    public void hideLoadingProgress() {
        if (mProgressLoadMore != null) {
            mProgressLoadMore.setVisibility(View.GONE);
        }
    }

    /*
     * add a menu to the right side of the toolbar, returns the toolbar menu so the caller
     * can act upon it
     */
    public Menu addToolbarMenu(@MenuRes int menuResId) {
        mToolbar.inflateMenu(menuResId);
        return mToolbar.getMenu();
    }

    public void setToolbarBackgroundColor(int color){
        mToolbar.setBackgroundColor(color);
    }

    public void setToolbarSpinnerTextColor(int color){
        mSpinnerTextColor = color;
    }

    public void setToolbarSpinnerDrawable(int drawableResId){
        mSpinnerDrawableRight = drawableResId;
    }

    public void setToolbarLeftPadding(int paddingLeft){
        mToolbar.setPadding(paddingLeft,
                mToolbar.getPaddingTop(),
                mToolbar.getPaddingRight(),
                mToolbar.getPaddingBottom());
    }

    public void setToolbarRightPadding(int paddingRight){
        mToolbar.setPadding(
                mToolbar.getPaddingLeft(),
                mToolbar.getPaddingTop(),
                paddingRight,
                mToolbar.getPaddingBottom());
    }

    public void setToolbarLeftAndRightPadding(int paddingLeft, int paddingRight){
        mToolbar.setPadding(
                paddingLeft,
                mToolbar.getPaddingTop(),
                paddingRight,
                mToolbar.getPaddingBottom());
    }

    public void scrollRecycleViewToPosition(int position) {
        if (mRecyclerView == null) return;

        mRecyclerView.scrollToPosition(position);
    }

    public int getCurrentPosition() {
        if (mRecyclerView != null && mRecyclerView.getLayoutManager() != null) {
            return ((LinearLayoutManager) mRecyclerView.getLayoutManager()).findFirstVisibleItemPosition();
        } else {
            return -1;
        }
    }

    public void smoothScrollToPosition(int position){
        if (mRecyclerView != null && mRecyclerView.getLayoutManager() != null) {
            mRecyclerView.getLayoutManager().smoothScrollToPosition(mRecyclerView, null, position);
        }
    }

    public void addItemDecoration(RecyclerView.ItemDecoration decor){
        if (mRecyclerView == null) return;

        mRecyclerView.addItemDecoration(decor);
    }

    public void addOnScrollListener(RecyclerView.OnScrollListener listener) {
        if (mRecyclerView != null) {
            mRecyclerView.addOnScrollListener(listener);
        }
    }

    public void removeOnScrollListener(RecyclerView.OnScrollListener listener) {
        if (mRecyclerView != null) {
            mRecyclerView.removeOnScrollListener(listener);
        }
    }

    public void hideToolbar(){
        mAppBarLayout.setExpanded(false, true);
    }

    public void showToolbar(){
        mAppBarLayout.setExpanded(true, true);
    }

    /*
    * use this if you need to reload the criterias for this FilteredRecyclerView. The actual data loading goes
    * through the FilteredRecyclerView lifecycle using its listeners:
    *
    * - FilterCriteriaAsyncLoaderListener
    * and
    *  - FilterListener.onLoadFilterCriteriaOptions
    * */
    public void refreshFilterCriteriaOptions(){
        setup(true);
    }

    /*
     * adapter used by the filter spinner
     */
    private class SpinnerAdapter extends BaseAdapter {
        private final List<FilterCriteria> mFilterValues;
        private final LayoutInflater mInflater;

        SpinnerAdapter(Context context, List<FilterCriteria> filterValues) {
            super();
            mInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
            mFilterValues = filterValues;
        }

        @Override
        public int getCount() {
            return (mFilterValues != null ? mFilterValues.size() : 0);
        }

        @Override
        public Object getItem(int position) {
            return mFilterValues.get(position);
        }

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

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            final View view;
            if (convertView == null) {
                view = mInflater.inflate(R.layout.filter_spinner_item, parent, false);

                final TextView text = (TextView) view.findViewById(R.id.text);
                FilterCriteria selectedCriteria = (FilterCriteria)getItem(position);
                text.setText(selectedCriteria.getLabel());
                if (mSpinnerTextColor != 0){
                    text.setTextColor(mSpinnerTextColor);
                }

                if (mSpinnerDrawableRight != 0){
                    text.setCompoundDrawablesWithIntrinsicBounds(0, 0, mSpinnerDrawableRight, 0);
                    text.setCompoundDrawablePadding(getResources().getDimensionPixelSize(R.dimen.margin_medium));
                    text.setGravity(Gravity.CENTER_VERTICAL | Gravity.LEFT);
                }

            } else {
                view = convertView;
            }

            return view;
        }

        @Override
        public View getDropDownView(int position, View convertView, ViewGroup parent) {
            FilterCriteria selectedCriteria = (FilterCriteria)getItem(position);
            final TagViewHolder holder;

            if (convertView == null) {
                convertView = mInflater.inflate(R.layout.toolbar_spinner_dropdown_item, parent, false);
                holder = new TagViewHolder(convertView);
                convertView.setTag(holder);
            } else {
                holder = (TagViewHolder) convertView.getTag();
            }

            holder.textView.setText(selectedCriteria.getLabel());
            return convertView;
        }

        private class TagViewHolder {
            private final TextView textView;
            TagViewHolder(View view) {
                textView = (TextView) view.findViewById(R.id.text);
            }
        }

        public int getIndexOfCriteria(FilterCriteria tm) {
            if (tm != null && mFilterValues != null){
                for (int i = 0; i < mFilterValues.size(); i++) {
                    FilterCriteria criteria = mFilterValues.get(i);
                    if (criteria != null && criteria.equals(tm)) {
                        return i;
                    }
                }
            }
            return -1;
        }
    }

    /*
     * returns true if the first item is still visible in the RecyclerView - will return
     * false if the first item is scrolled out of view, or if the list is empty
     */
    public boolean isFirstItemVisible() {
        if (mRecyclerView == null
                || mRecyclerView.getLayoutManager() == null) {
            return false;
        }

        View child = mRecyclerView.getLayoutManager().getChildAt(0);
        return (child != null && mRecyclerView.getLayoutManager().getPosition(child) == 0);
    }


    /**
     * implement this interface to use FilterRecyclerView
     */
    public interface FilterListener {
        /**
         * Called upon initialization - provide an array of FilterCriterias here. These are the possible criterias
         * the Spinner is loaded with, and through which the data can be filtered.
         *
         * @param refresh "true"if the criterias need be refreshed
         * @return an array of FilterCriteria to be used on Spinner initialization, or null if going to use the
         *          Async method below
         */
        List<FilterCriteria> onLoadFilterCriteriaOptions(boolean refresh);

        /**
         * Called upon initialization - you can use this callback to start an asynctask to build an array of
         * FilterCriterias here. Once the AsyncTask is done, it should call the provided listener
         * The Spinner is then loaded with such array of FilterCriterias, through which the main data can be filtered.
         *
         * @param listener to be called to pass the FilterCriteria array when done
         * @param refresh "true"if the criterias need be refreshed
         */
        void onLoadFilterCriteriaOptionsAsync(FilterCriteriaAsyncLoaderListener listener, boolean refresh);

        /**
         * Called upon initialization, right after onLoadFilterCriteriaOptions().
         * Once the criteria options are set up, use this callback to return the latest option selected on the
         * screen the last time the user visited it, or a default value for the filter Spinner to be initialized with.
         *
         * @return
         */
        FilterCriteria onRecallSelection();

        /**
         * When this method is called, you should load data into the FilteredRecyclerView adapter, using the
         * latest criteria passed to you in a previous onFilterSelected() call.
         * Within the FilteredRecyclerView lifecycle, this is triggered in three different moments:
         * 1 - upon initialisation
         * 2 - each time a screen refresh is requested
         * 3 - each time the user changes the filter spinner selection
         */
        void onLoadData();

        /**
         * Called each time the user changes the Spinner selection (i.e. changes the criteria on which to filter
         * the data). You should only take note of the change, and remember it, as a request to load data with
         * the newly selected filter shall always arrive through onLoadData().
         * The parameters passed in this callback can be used alternatively as per your convenience.
         *
         * @param position of the selected criteria within the array returned by onLoadFilterCriteriaOptions()
         * @param criteria the actual criteria selected
         */
        void onFilterSelected(int position, FilterCriteria criteria);

        /**
         * Called when there's no data to show.
         *
         * @param emptyViewMsgType this will hint you on the reason why no data is being shown, so you can return
         *                         a proper message to be displayed to the user
         * @return the message to be displayed to the user, or null if using a Custom Empty View (see below)
         */
        String onShowEmptyViewMessage(EmptyViewMessageType emptyViewMsgType);

        /**
         * Called when there's no data to show, and only if a custom EmptyView is set (onShowEmptyViewMessage will
         * be called otherwise).
         *
         * @param emptyViewMsgType this will hint you on the reason why no data is being shown, and
         *                         also here you should perform any actions on your custom empty view
         * @return nothing
         */
        void onShowCustomEmptyView(EmptyViewMessageType emptyViewMsgType);

    }

    /**
     * implement this interface to load filtering options (that is, an array of FilterCriteria) asynchronously
     */
    public interface FilterCriteriaAsyncLoaderListener{
        /**
         * Will be called during initialization of FilteredRecyclerView once you're ready building the FilterCriteria array
         *
         * @param criteriaList the array of FilterCriteria objects you just built
         */
        void onFilterCriteriasLoaded(List<FilterCriteria> criteriaList);
    }

}