/*
 * Copyright (C) 2017 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.dialer.speeddial;

import android.Manifest;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Bundle;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import android.provider.ContactsContract.Contacts;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.VisibleForTesting;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.FragmentManager;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.helper.ItemTouchHelper;
import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import com.android.dialer.callintent.CallInitiationType;
import com.android.dialer.callintent.CallIntentBuilder;
import com.android.dialer.common.Assert;
import com.android.dialer.common.FragmentUtils;
import com.android.dialer.common.LogUtil;
import com.android.dialer.common.concurrent.DefaultFutureCallback;
import com.android.dialer.common.concurrent.DialerExecutorComponent;
import com.android.dialer.common.concurrent.SupportUiListener;
import com.android.dialer.common.concurrent.ThreadUtil;
import com.android.dialer.constants.ActivityRequestCodes;
import com.android.dialer.historyitemactions.DividerModule;
import com.android.dialer.historyitemactions.HistoryItemActionBottomSheet;
import com.android.dialer.historyitemactions.HistoryItemActionModule;
import com.android.dialer.historyitemactions.HistoryItemBottomSheetHeaderInfo;
import com.android.dialer.historyitemactions.IntentModule;
import com.android.dialer.logging.DialerImpression;
import com.android.dialer.logging.Logger;
import com.android.dialer.precall.PreCall;
import com.android.dialer.shortcuts.ShortcutRefresher;
import com.android.dialer.speeddial.ContextMenu.ContextMenuItemListener;
import com.android.dialer.speeddial.FavoritesViewHolder.FavoriteContactsListener;
import com.android.dialer.speeddial.HeaderViewHolder.SpeedDialHeaderListener;
import com.android.dialer.speeddial.SuggestionViewHolder.SuggestedContactsListener;
import com.android.dialer.speeddial.database.SpeedDialEntry.Channel;
import com.android.dialer.speeddial.draghelper.SpeedDialItemTouchHelperCallback;
import com.android.dialer.speeddial.draghelper.SpeedDialLayoutManager;
import com.android.dialer.speeddial.loader.SpeedDialUiItem;
import com.android.dialer.speeddial.loader.UiItemLoaderComponent;
import com.android.dialer.util.IntentUtil;
import com.android.dialer.util.PermissionsUtil;
import com.android.dialer.widget.EmptyContentView;
import com.android.dialer.widget.EmptyContentView.OnEmptyViewActionButtonClickedListener;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Fragment for displaying:
 *
 * <ul>
 *   <li>Favorite/Starred contacts
 *   <li>Suggested contacts
 * </ul>
 *
 * <p>Suggested contacts built from {@link android.provider.ContactsContract#STREQUENT_PHONE_ONLY}.
 */
public class SpeedDialFragment extends Fragment {

  private static final int READ_CONTACTS_PERMISSION_REQUEST_CODE = 1;

  /**
   * Listen to broadcast events about permissions in order to be notified if the READ_CONTACTS
   * permission is granted via the UI in another fragment.
   */
  private final BroadcastReceiver readContactsPermissionGrantedReceiver =
      new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
          loadContacts();
        }
      };

  /** Listen for changes to the strequents content observer. */
  private final ContentObserver strequentsContentObserver =
      new ContentObserver(ThreadUtil.getUiThreadHandler()) {
        @Override
        public void onChange(boolean selfChange) {
          super.onChange(selfChange);
          loadContacts();
        }
      };

  private final SpeedDialHeaderListener headerListener = new SpeedDialFragmentHeaderListener();
  private final SpeedDialSuggestedListener suggestedListener = new SpeedDialSuggestedListener();

  private SpeedDialAdapter adapter;
  private SupportUiListener<ImmutableList<SpeedDialUiItem>> speedDialLoaderListener;
  private SpeedDialFavoritesListener favoritesListener;

  private EmptyContentView emptyContentView;

  /**
   * We update the UI every time the fragment is resumed. This boolean suppresses that functionality
   * once per onResume call.
   */
  private boolean updateSpeedDialItemsOnResume = true;

  public static SpeedDialFragment newInstance() {
    return new SpeedDialFragment();
  }

  @Nullable
  @Override
  public View onCreateView(
      LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    LogUtil.enterBlock("SpeedDialFragment.onCreateView");
    View rootLayout = inflater.inflate(R.layout.fragment_speed_dial, container, false);
    emptyContentView = rootLayout.findViewById(R.id.speed_dial_empty_content_view);
    emptyContentView.setImage(R.drawable.empty_speed_dial);

    speedDialLoaderListener =
        DialerExecutorComponent.get(getContext())
            .createUiListener(getChildFragmentManager(), "speed_dial_loader_listener");

    // Setup our RecyclerView
    SpeedDialLayoutManager layoutManager =
        new SpeedDialLayoutManager(getContext(), 3 /* spanCount */);
    favoritesListener =
        new SpeedDialFavoritesListener(
            getActivity(),
            getChildFragmentManager(),
            layoutManager,
            new UpdateSpeedDialAdapterListener(),
            speedDialLoaderListener);
    adapter =
        new SpeedDialAdapter(
            getContext(),
            favoritesListener,
            suggestedListener,
            headerListener,
            FragmentUtils.getParentUnsafe(this, HostInterface.class));
    layoutManager.setSpanSizeLookup(adapter.getSpanSizeLookup());
    RecyclerView recyclerView = rootLayout.findViewById(R.id.speed_dial_recycler_view);
    recyclerView.setLayoutManager(layoutManager);
    recyclerView.setAdapter(adapter);

    // Setup drag and drop touch helper
    ItemTouchHelper.Callback callback = new SpeedDialItemTouchHelperCallback(getContext(), adapter);
    ItemTouchHelper touchHelper = new ItemTouchHelper(callback);
    touchHelper.attachToRecyclerView(recyclerView);
    adapter.setItemTouchHelper(touchHelper);
    return rootLayout;
  }

  @Override
  public void onResume() {
    super.onResume();
    loadContacts();
  }

  @Override
  public void onPause() {
    super.onPause();
    favoritesListener.hideMenu();
    suggestedListener.onPause();
    onHidden();
  }

  @Override
  public void onHiddenChanged(boolean hidden) {
    super.onHiddenChanged(hidden);
    if (hidden) {
      onHidden();
    } else {
      loadContacts();
    }
  }

  private void onHidden() {
    if (!PermissionsUtil.hasContactsReadPermissions(getContext())) {
      return;
    }

    Futures.addCallback(
        DialerExecutorComponent.get(getContext())
            .backgroundExecutor()
            .submit(
                () -> {
                  UiItemLoaderComponent.get(getContext())
                      .speedDialUiItemMutator()
                      .updatePinnedPosition(adapter.getSpeedDialUiItems());
                  return null;
                }),
        new DefaultFutureCallback<>(),
        DialerExecutorComponent.get(getContext()).backgroundExecutor());
    ShortcutRefresher.refresh(
        getContext(),
        ShortcutRefresher.speedDialUiItemsToContactEntries(adapter.getSpeedDialUiItems()));
  }

  @Override
  public void onRequestPermissionsResult(
      int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    if (requestCode == READ_CONTACTS_PERMISSION_REQUEST_CODE
        && grantResults.length > 0
        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
      PermissionsUtil.notifyPermissionGranted(getContext(), Manifest.permission.READ_CONTACTS);
      loadContacts();
    }
  }

  private void loadContacts() {
    if (!updateSpeedDialItemsOnResume) {
      updateSpeedDialItemsOnResume = true;
      return;
    }

    if (showContactsPermissionEmptyContentView()) {
      return;
    }

    speedDialLoaderListener.listen(
        getContext(),
        UiItemLoaderComponent.get(getContext()).speedDialUiItemMutator().loadSpeedDialUiItems(),
        this::onSpeedDialUiItemListLoaded,
        throwable -> {
          throw new RuntimeException(throwable);
        });
  }

  @Override
  public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == ActivityRequestCodes.SPEED_DIAL_ADD_FAVORITE) {
      if (resultCode == AppCompatActivity.RESULT_OK && data.getData() != null) {
        Logger.get(getContext()).logImpression(DialerImpression.Type.FAVORITE_ADD_FAVORITE);
        updateSpeedDialItemsOnResume = false;
        speedDialLoaderListener.listen(
            getContext(),
            UiItemLoaderComponent.get(getContext())
                .speedDialUiItemMutator()
                .starContact(data.getData()),
            this::onSpeedDialUiItemListLoaded,
            throwable -> {
              throw new RuntimeException(throwable);
            });
      }
    }
  }

  private void onSpeedDialUiItemListLoaded(ImmutableList<SpeedDialUiItem> speedDialUiItems) {
    LogUtil.enterBlock("SpeedDialFragment.onSpeedDialUiItemListLoaded");
    // TODO(calderwoodra): Use DiffUtil to properly update and animate the change
    adapter.setSpeedDialUiItems(
        UiItemLoaderComponent.get(getContext())
            .speedDialUiItemMutator()
            .insertDuoChannels(getContext(), speedDialUiItems));
    adapter.notifyDataSetChanged();
    maybeShowNoContactsEmptyContentView();

    if (getActivity() != null) {
      FragmentUtils.getParentUnsafe(this, HostInterface.class)
          .setHasFrequents(adapter.hasFrequents());
    }
  }

  /** Returns true if the empty content view was shown. */
  private boolean showContactsPermissionEmptyContentView() {
    if (PermissionsUtil.hasContactsReadPermissions(getContext())) {
      emptyContentView.setVisibility(View.GONE);
      return false;
    }

    emptyContentView.setVisibility(View.VISIBLE);
    emptyContentView.setActionLabel(R.string.speed_dial_turn_on_contacts_permission);
    emptyContentView.setDescription(R.string.speed_dial_contacts_permission_description);
    emptyContentView.setActionClickedListener(
        new SpeedDialContactPermissionEmptyViewListener(getContext(), this));
    return true;
  }

  private void maybeShowNoContactsEmptyContentView() {
    if (adapter.getItemCount() != 0) {
      emptyContentView.setVisibility(View.GONE);
      return;
    }

    emptyContentView.setVisibility(View.VISIBLE);
    emptyContentView.setActionLabel(R.string.speed_dial_no_contacts_action_text);
    emptyContentView.setDescription(R.string.speed_dial_no_contacts_description);
    emptyContentView.setActionClickedListener(new SpeedDialNoContactsEmptyViewListener(this));
  }

  @Override
  public void onStart() {
    super.onStart();
    PermissionsUtil.registerPermissionReceiver(
        getActivity(), readContactsPermissionGrantedReceiver, Manifest.permission.READ_CONTACTS);
    if (PermissionsUtil.hasContactsReadPermissions(getContext())) {
      getContext()
          .getContentResolver()
          .registerContentObserver(Contacts.CONTENT_STREQUENT_URI, true, strequentsContentObserver);
    }
  }

  @Override
  public void onStop() {
    super.onStop();
    PermissionsUtil.unregisterPermissionReceiver(
        getContext(), readContactsPermissionGrantedReceiver);
    getContext().getContentResolver().unregisterContentObserver(strequentsContentObserver);
  }

  private class SpeedDialFragmentHeaderListener implements SpeedDialHeaderListener {

    @Override
    public void onAddFavoriteClicked() {
      Intent intent = new Intent(Intent.ACTION_PICK, Phone.CONTENT_URI);
      startActivityForResult(intent, ActivityRequestCodes.SPEED_DIAL_ADD_FAVORITE);
    }
  }

  @VisibleForTesting
  static final class SpeedDialFavoritesListener implements FavoriteContactsListener {

    private final FragmentActivity activity;
    private final FragmentManager childFragmentManager;
    private final SpeedDialLayoutManager layoutManager;
    private final UpdateSpeedDialAdapterListener updateAdapterListener;
    private final SupportUiListener<ImmutableList<SpeedDialUiItem>> speedDialLoaderListener;

    private final SpeedDialContextMenuItemListener speedDialContextMenuItemListener =
        new SpeedDialContextMenuItemListener();

    private ContextMenu contextMenu;

    SpeedDialFavoritesListener(
        FragmentActivity activity,
        FragmentManager childFragmentManager,
        SpeedDialLayoutManager layoutManager,
        UpdateSpeedDialAdapterListener updateAdapterListener,
        SupportUiListener<ImmutableList<SpeedDialUiItem>> speedDialLoaderListener) {
      this.activity = activity;
      this.childFragmentManager = childFragmentManager;
      this.layoutManager = layoutManager;
      this.updateAdapterListener = updateAdapterListener;
      this.speedDialLoaderListener = speedDialLoaderListener;
    }

    @Override
    public void onAmbiguousContactClicked(SpeedDialUiItem speedDialUiItem) {
      // If there is only one channel, skip the menu and place a call directly
      if (speedDialUiItem.channels().size() == 1) {
        onClick(speedDialUiItem.channels().get(0));
        return;
      }

      Logger.get(activity).logImpression(DialerImpression.Type.FAVORITE_OPEN_DISAMBIG_DIALOG);
      DisambigDialog.show(speedDialUiItem, childFragmentManager);
    }

    @Override
    public void onClick(Channel channel) {
      if (channel.technology() == Channel.DUO) {
        Logger.get(activity)
            .logImpression(DialerImpression.Type.LIGHTBRINGER_VIDEO_REQUESTED_FOR_FAVORITE_CONTACT);
      }

      PreCall.start(
          activity,
          new CallIntentBuilder(channel.number(), CallInitiationType.Type.SPEED_DIAL)
              .setAllowAssistedDial(true)
              .setIsVideoCall(channel.isVideoTechnology())
              .setIsDuoCall(channel.technology() == Channel.DUO));
    }

    @Override
    public void showContextMenu(View view, SpeedDialUiItem speedDialUiItem) {
      Logger.get(activity).logImpression(DialerImpression.Type.FAVORITE_OPEN_FAVORITE_MENU);
      layoutManager.setScrollEnabled(false);
      contextMenu =
          ContextMenu.show(activity, view, speedDialContextMenuItemListener, speedDialUiItem);
    }

    @Override
    public void onTouchFinished(boolean closeContextMenu) {
      layoutManager.setScrollEnabled(true);

      if (closeContextMenu) {
        contextMenu.hide();
        contextMenu = null;
      }
    }

    @Override
    public void onRequestRemove(SpeedDialUiItem speedDialUiItem) {
      Logger.get(activity)
          .logImpression(DialerImpression.Type.FAVORITE_REMOVE_FAVORITE_BY_DRAG_AND_DROP);
      speedDialContextMenuItemListener.removeFavoriteContact(speedDialUiItem);
    }

    void hideMenu() {
      if (contextMenu != null) {
        contextMenu.hide();
        contextMenu = null;
      }
    }

    public SpeedDialContextMenuItemListener getSpeedDialContextMenuItemListener() {
      return speedDialContextMenuItemListener;
    }

    class SpeedDialContextMenuItemListener implements ContextMenuItemListener {

      @Override
      public void placeCall(Channel channel) {
        if (channel.technology() == Channel.DUO) {
          Logger.get(activity)
              .logImpression(
                  DialerImpression.Type.LIGHTBRINGER_VIDEO_REQUESTED_FOR_FAVORITE_CONTACT);
        }
        PreCall.start(
            activity,
            new CallIntentBuilder(channel.number(), CallInitiationType.Type.SPEED_DIAL)
                .setAllowAssistedDial(true)
                .setIsVideoCall(channel.isVideoTechnology())
                .setIsDuoCall(channel.technology() == Channel.DUO));
      }

      @Override
      public void openSmsConversation(String number) {
        Logger.get(activity).logImpression(DialerImpression.Type.FAVORITE_SEND_MESSAGE);
        activity.startActivity(IntentUtil.getSendSmsIntent(number));
      }

      @Override
      public void removeFavoriteContact(SpeedDialUiItem speedDialUiItem) {
        Logger.get(activity).logImpression(DialerImpression.Type.FAVORITE_REMOVE_FAVORITE);
        speedDialLoaderListener.listen(
            activity,
            UiItemLoaderComponent.get(activity)
                .speedDialUiItemMutator()
                .removeSpeedDialUiItem(speedDialUiItem),
            updateAdapterListener::updateAdapter,
            throwable -> {
              throw new RuntimeException(throwable);
            });
      }

      @Override
      public void openContactInfo(SpeedDialUiItem speedDialUiItem) {
        Logger.get(activity).logImpression(DialerImpression.Type.FAVORITE_OPEN_CONTACT_CARD);
        activity.startActivity(
            new Intent(
                Intent.ACTION_VIEW,
                Uri.withAppendedPath(
                    Contacts.CONTENT_URI, String.valueOf(speedDialUiItem.contactId()))));
      }
    }
  }

  private final class SpeedDialSuggestedListener implements SuggestedContactsListener {

    private HistoryItemActionBottomSheet bottomSheet;

    @Override
    public void onOverFlowMenuClicked(
        SpeedDialUiItem speedDialUiItem, HistoryItemBottomSheetHeaderInfo headerInfo) {
      List<HistoryItemActionModule> modules = new ArrayList<>();
      Channel defaultChannel = speedDialUiItem.defaultChannel();

      // Add voice call module
      Channel voiceChannel = speedDialUiItem.getDefaultVoiceChannel();
      if (voiceChannel != null) {
        modules.add(
            IntentModule.newCallModule(
                getContext(),
                new CallIntentBuilder(voiceChannel.number(), CallInitiationType.Type.SPEED_DIAL)
                    .setAllowAssistedDial(true)));
      }

      // Add video if we can determine the correct channel
      Channel videoChannel = speedDialUiItem.getDefaultVideoChannel();
      if (videoChannel != null) {
        modules.add(
            IntentModule.newCallModule(
                getContext(),
                new CallIntentBuilder(videoChannel.number(), CallInitiationType.Type.SPEED_DIAL)
                    .setIsVideoCall(true)
                    .setAllowAssistedDial(true)));
      }

      // Add sms module
      if (!TextUtils.isEmpty(defaultChannel.number())) {
        modules.add(
            IntentModule.newModuleForSendingTextMessage(getContext(), defaultChannel.number()));
      }

      modules.add(new DividerModule());

      modules.add(new StarContactModule(speedDialUiItem));
      // TODO(calderwoodra): remove from strequent module

      // Contact info module
      modules.add(
          new ContactInfoModule(
              getContext(),
              new Intent(
                  Intent.ACTION_VIEW,
                  Uri.withAppendedPath(
                      Contacts.CONTENT_URI, String.valueOf(speedDialUiItem.contactId()))),
              R.string.contact_menu_contact_info,
              R.drawable.context_menu_contact_icon));

      bottomSheet = HistoryItemActionBottomSheet.show(getContext(), headerInfo, modules);
    }

    @Override
    public void onRowClicked(Channel channel) {
      if (channel.technology() == Channel.DUO) {
        Logger.get(getContext())
            .logImpression(
                DialerImpression.Type.LIGHTBRINGER_VIDEO_REQUESTED_FOR_SUGGESTED_CONTACT);
      }
      PreCall.start(
          getContext(),
          new CallIntentBuilder(channel.number(), CallInitiationType.Type.SPEED_DIAL)
              .setAllowAssistedDial(true)
              .setIsVideoCall(channel.isVideoTechnology())
              .setIsDuoCall(channel.technology() == Channel.DUO));
    }

    private final class StarContactModule implements HistoryItemActionModule {

      private final SpeedDialUiItem speedDialUiItem;

      StarContactModule(SpeedDialUiItem speedDialUiItem) {
        this.speedDialUiItem = speedDialUiItem;
      }

      @Override
      public int getStringId() {
        return R.string.suggested_contact_bottom_sheet_add_favorite_option;
      }

      @Override
      public int getDrawableId() {
        return R.drawable.quantum_ic_star_vd_theme_24;
      }

      @Override
      public boolean onClick() {
        speedDialLoaderListener.listen(
            getContext(),
            UiItemLoaderComponent.get(getContext())
                .speedDialUiItemMutator()
                .starContact(
                    Uri.withAppendedPath(
                        Phone.CONTENT_FILTER_URI, speedDialUiItem.defaultChannel().number())),
            SpeedDialFragment.this::onSpeedDialUiItemListLoaded,
            throwable -> {
              throw new RuntimeException(throwable);
            });
        return true;
      }
    }

    private final class ContactInfoModule extends IntentModule {

      public ContactInfoModule(Context context, Intent intent, int text, int image) {
        super(context, intent, text, image);
      }

      @Override
      public boolean tintDrawable() {
        return false;
      }
    }

    public void onPause() {
      if (bottomSheet != null && bottomSheet.isShowing()) {
        bottomSheet.dismiss();
      }
    }
  }

  private static final class SpeedDialContactPermissionEmptyViewListener
      implements OnEmptyViewActionButtonClickedListener {

    private final Context context;
    private final Fragment fragment;

    private SpeedDialContactPermissionEmptyViewListener(Context context, Fragment fragment) {
      this.context = context;
      this.fragment = fragment;
    }

    @Override
    public void onEmptyViewActionButtonClicked() {
      String[] deniedPermissions =
          PermissionsUtil.getPermissionsCurrentlyDenied(
              context, PermissionsUtil.allContactsGroupPermissionsUsedInDialer);
      Assert.checkArgument(deniedPermissions.length > 0);
      LogUtil.i(
          "OldSpeedDialFragment.onEmptyViewActionButtonClicked",
          "Requesting permissions: " + Arrays.toString(deniedPermissions));
      fragment.requestPermissions(deniedPermissions, READ_CONTACTS_PERMISSION_REQUEST_CODE);
    }
  }

  private static final class SpeedDialNoContactsEmptyViewListener
      implements OnEmptyViewActionButtonClickedListener {

    private final Fragment fragment;

    SpeedDialNoContactsEmptyViewListener(Fragment fragment) {
      this.fragment = fragment;
    }

    @Override
    public void onEmptyViewActionButtonClicked() {
      Intent intent = new Intent(Intent.ACTION_PICK, Phone.CONTENT_URI);
      fragment.startActivityForResult(intent, ActivityRequestCodes.SPEED_DIAL_ADD_FAVORITE);
    }
  }

  /** Listener for when a SpeedDialUiItem is updated. */
  class UpdateSpeedDialAdapterListener {

    void updateAdapter(ImmutableList<SpeedDialUiItem> speedDialUiItems) {
      onSpeedDialUiItemListLoaded(speedDialUiItems);
    }
  }

  /** Interface for {@link SpeedDialFragment} to communicate with its host/parent. */
  public interface HostInterface {

    void setHasFrequents(boolean hasFrequents);

    void dragFavorite(boolean start);
  }
}