/*
 * Copyright 2018 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 androidx.recyclerview.widget;


import static androidx.recyclerview.widget.RecyclerView.HORIZONTAL;
import static androidx.recyclerview.widget.RecyclerView.SCROLL_STATE_IDLE;
import static androidx.recyclerview.widget.RecyclerView.VERTICAL;

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertTrue;

import android.app.Activity;
import android.content.Context;
import android.os.Build;
import android.support.test.InstrumentationRegistry;
import android.support.test.filters.LargeTest;
import android.support.test.rule.ActivityTestRule;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.widget.LinearLayout;

import androidx.annotation.NonNull;
import androidx.core.view.ViewCompat;
import androidx.recyclerview.test.R;
import androidx.recyclerview.test.RecyclerViewTestActivity;

import org.hamcrest.BaseMatcher;
import org.hamcrest.CoreMatchers;
import org.hamcrest.Description;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * This class tests RecyclerView focus search failure handling by using a real LayoutManager.
 */
@LargeTest
@RunWith(Parameterized.class)
public class FocusSearchNavigationTest {
    @Rule
    public ActivityTestRule<RecyclerViewTestActivity> mActivityRule =
            new ActivityTestRule<>(RecyclerViewTestActivity.class);

    private final int mOrientation;
    private final int mLayoutDir;

    public FocusSearchNavigationTest(int orientation, int layoutDir) {
        mOrientation = orientation;
        mLayoutDir = layoutDir;
    }

    @Parameterized.Parameters(name = "orientation:{0},layoutDir:{1}")
    public static List<Object[]> params() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            return Arrays.asList(
                    new Object[]{VERTICAL, ViewCompat.LAYOUT_DIRECTION_LTR},
                    new Object[]{HORIZONTAL, ViewCompat.LAYOUT_DIRECTION_LTR},
                    new Object[]{HORIZONTAL, ViewCompat.LAYOUT_DIRECTION_RTL}
            );
        } else {
            // Do not test RTL before API 17
            return Arrays.asList(
                    new Object[]{VERTICAL, ViewCompat.LAYOUT_DIRECTION_LTR},
                    new Object[]{HORIZONTAL, ViewCompat.LAYOUT_DIRECTION_LTR}
            );
        }
    }

    private Activity mActivity;
    private RecyclerView mRecyclerView;
    private View mBefore;
    private View mAfter;

    private void setup(final int itemCount) throws Throwable {
        mActivity = mActivityRule.getActivity();
        mActivityRule.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mActivity.setContentView(R.layout.focus_search_activity);
                ViewCompat.setLayoutDirection(mActivity.getWindow().getDecorView(), mLayoutDir);
                LinearLayout linearLayout = (LinearLayout) mActivity.findViewById(R.id.root);
                linearLayout.setOrientation(mOrientation);
                mRecyclerView = (RecyclerView) mActivity.findViewById(R.id.recycler_view);
                ViewCompat.setLayoutDirection(mRecyclerView, mLayoutDir);
                LinearLayoutManager layout = new LinearLayoutManager(mActivity.getBaseContext());
                layout.setOrientation(mOrientation);
                mRecyclerView.setLayoutManager(layout);
                mRecyclerView.setAdapter(new FocusSearchAdapter(itemCount, mOrientation));
                if (mOrientation == VERTICAL) {
                    mRecyclerView.setLayoutParams(new LinearLayout.LayoutParams(
                            ViewGroup.LayoutParams.MATCH_PARENT, 250));
                } else {
                    mRecyclerView.setLayoutParams(new LinearLayout.LayoutParams(
                            250, ViewGroup.LayoutParams.MATCH_PARENT));
                }

                mBefore = mActivity.findViewById(R.id.before);
                mAfter = mActivity.findViewById(R.id.after);
            }
        });
        waitForIdleSync();
        assertThat("test sanity", mRecyclerView.getLayoutManager().getLayoutDirection(),
                is(mLayoutDir));
        assertThat("test sanity", ViewCompat.getLayoutDirection(mRecyclerView), is(mLayoutDir));
    }

    @Test
    public void focusSearchForward() throws Throwable {
        setup(20);
        requestFocus(mBefore);
        assertThat(mBefore, hasFocus());
        View focused = mBefore;
        for (int i = 0; i < 20; i++) {
            focusSearchAndGive(focused, View.FOCUS_FORWARD);
            RecyclerView.ViewHolder viewHolder = mRecyclerView.findViewHolderForAdapterPosition(i);
            assertThat("vh at " + i, viewHolder, hasFocus());
            focused = viewHolder.itemView;
        }
        focusSearchAndGive(focused, View.FOCUS_FORWARD);
        assertThat(mAfter, hasFocus());
        focusSearchAndGive(mAfter, View.FOCUS_FORWARD);
        assertThat(mBefore, hasFocus());
        focusSearchAndGive(mBefore, View.FOCUS_FORWARD);
        focused = mActivity.getCurrentFocus();
        //noinspection ConstantConditions
        assertThat(focused.getParent(), CoreMatchers.<ViewParent>sameInstance(mRecyclerView));
    }

    @Test
    public void focusSearchBackwards() throws Throwable {
        setup(20);
        requestFocus(mAfter);
        assertThat(mAfter, hasFocus());
        View focused = mAfter;
        RecyclerView.ViewHolder lastViewHolder = null;
        int i = 20;
        while(lastViewHolder == null) {
            lastViewHolder = mRecyclerView.findViewHolderForAdapterPosition(--i);
        }
        assertThat(lastViewHolder, notNullValue());

        while(i >= 0) {
            focusSearchAndGive(focused, View.FOCUS_BACKWARD);
            RecyclerView.ViewHolder viewHolder = mRecyclerView.findViewHolderForAdapterPosition(i);
            assertThat("vh at " + i, viewHolder, hasFocus());
            focused = viewHolder.itemView;
            i--;
        }
        focusSearchAndGive(focused, View.FOCUS_BACKWARD);
        assertThat(mBefore, hasFocus());
        focusSearchAndGive(mBefore, View.FOCUS_BACKWARD);
        assertThat(mAfter, hasFocus());
    }

    private View focusSearchAndGive(final View view, final int focusDir) throws Throwable {
        View next = focusSearch(view, focusDir);
        if (next != null && next != view) {
            requestFocus(next);
            return next;
        }
        return null;
    }

    private View focusSearch(final View view, final int focusDir) throws Throwable {
        final View[] result = new View[1];
        mActivityRule.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                result[0] = view.focusSearch(focusDir);
            }
        });
        waitForIdleSync();
        return result[0];
    }

    private void waitForIdleSync() throws Throwable {
        waitForIdleScroll(mRecyclerView);
        InstrumentationRegistry.getInstrumentation().waitForIdleSync();
    }

    private void requestFocus(final View view) throws Throwable {
        mActivityRule.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                view.requestFocus();
            }
        });
        waitForIdleSync();
    }

    public void waitForIdleScroll(final RecyclerView recyclerView) throws Throwable {
        final CountDownLatch latch = new CountDownLatch(1);
        mActivityRule.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                RecyclerView.OnScrollListener listener = new RecyclerView.OnScrollListener() {
                    @Override
                    public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
                        if (newState == SCROLL_STATE_IDLE) {
                            latch.countDown();
                            recyclerView.removeOnScrollListener(this);
                        }
                    }
                };
                if (recyclerView.getScrollState() == SCROLL_STATE_IDLE) {
                    latch.countDown();
                } else {
                    recyclerView.addOnScrollListener(listener);
                }
            }
        });
        assertTrue("should go idle in 10 seconds", latch.await(10, TimeUnit.SECONDS));
    }

    static class FocusSearchAdapter extends RecyclerView.Adapter {
        private int mItemCount;
        private int mOrientation;
        public FocusSearchAdapter(int itemCount, int orientation) {
            mItemCount = itemCount;
            mOrientation = orientation;
        }

        @Override
        public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent,
        int viewType) {
            View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_view,
                    parent, false);
            if (mOrientation == VERTICAL) {
                view.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
                        50));
            } else {
                view.setLayoutParams(new ViewGroup.LayoutParams(50,
                        ViewGroup.LayoutParams.MATCH_PARENT));
            }
            return new RecyclerView.ViewHolder(view) {};
        }

        @Override
        public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
            holder.itemView.setTag("pos " + position);
        }

        @Override
        public int getItemCount() {
            return mItemCount;
        }
    }

    static HasFocusMatcher hasFocus() {
        return new HasFocusMatcher();
    }

    static class HasFocusMatcher extends BaseMatcher<Object> {
        @Override
        public boolean matches(Object item) {
            if (item instanceof RecyclerView.ViewHolder) {
                item = ((RecyclerView.ViewHolder) item).itemView;
            }
            return item instanceof View && ((View) item).hasFocus();
        }

        @Override
        public void describeTo(Description description) {
            description.appendText("view has focus");
        }

        private String objectToLog(Object item) {
            if (item instanceof RecyclerView.ViewHolder) {
                RecyclerView.ViewHolder vh = (RecyclerView.ViewHolder) item;
                return vh.toString();
            }
            if (item instanceof View) {
                final Object tag = ((View) item).getTag();
                return tag == null ? item.toString() : tag.toString();
            }
            final String classLog = item == null ? "null" : item.getClass().getSimpleName();
            return classLog;
        }

        @Override
        public void describeMismatch(Object item, Description description) {
            String noun = objectToLog(item);
            description.appendText(noun + " does not have focus");
            Context context = null;
            if (item instanceof RecyclerView.ViewHolder) {
                context = ((RecyclerView.ViewHolder)item).itemView.getContext();
            } else  if (item instanceof View) {
                context = ((View) item).getContext();
            }
            if (context instanceof Activity) {
                View currentFocus = ((Activity) context).getWindow().getCurrentFocus();
                description.appendText(". Current focus is in " + objectToLog(currentFocus));
            }
        }
    }
}