/*
 * Copyright (C) 2020 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.google.android.connecteddevice.service;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.refEq;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;

import android.os.ParcelUuid;
import androidx.annotation.NonNull;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import com.google.android.connecteddevice.ConnectedDeviceManager;
import com.google.android.connecteddevice.ConnectedDeviceManager.ConnectionCallback;
import com.google.android.connecteddevice.ConnectedDeviceManager.DeviceAssociationCallback;
import com.google.android.connecteddevice.ConnectedDeviceManager.DeviceCallback;
import com.google.android.connecteddevice.api.IConnectionCallback;
import com.google.android.connecteddevice.api.IDeviceAssociationCallback;
import com.google.android.connecteddevice.api.IDeviceCallback;
import com.google.android.connecteddevice.api.IOnLogRequestedListener;
import com.google.android.connecteddevice.logging.LoggingManager;
import com.google.android.connecteddevice.logging.LoggingManager.OnLogRequestedListener;
import com.google.android.connecteddevice.model.AssociatedDevice;
import com.google.android.connecteddevice.model.ConnectedDevice;
import com.google.android.connecteddevice.util.ByteUtils;
import java.util.UUID;
import java.util.concurrent.Executor;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;

@RunWith(AndroidJUnit4.class)
public class ConnectedDeviceManagerBinderTest {

  private final ParcelUuid recipientId = new ParcelUuid(UUID.randomUUID());

  @Rule public final MockitoRule mockito = MockitoJUnit.rule();
  @Mock private ConnectedDeviceManager mockConnectedDeviceManager;
  @Mock private LoggingManager mockLoggingManager;

  private ConnectedDeviceManagerBinder binder;

  @Before
  public void setUp() {
    binder =
        new ConnectedDeviceManagerBinder(
            mockConnectedDeviceManager, mockLoggingManager);
  }

  @Test
  public void registerActiveUserConnectionCallback_mirrorsConnectedDeviceManager() {
    binder.registerActiveUserConnectionCallback(createConnectionCallback());
    verify(mockConnectedDeviceManager)
        .registerActiveUserConnectionCallback(any(ConnectionCallback.class), any(Executor.class));
  }

  @Test
  public void unregisterConnectionCallback_mirrorsConnectedDeviceManager() {
    IConnectionCallback callback = createConnectionCallback();
    binder.registerActiveUserConnectionCallback(callback);
    binder.unregisterConnectionCallback(callback);
    verify(mockConnectedDeviceManager).unregisterConnectionCallback(any(ConnectionCallback.class));
  }

  @Test
  public void registerDeviceCallback_mirrorsConnectedDeviceManager() {
    IDeviceCallback deviceCallback = createDeviceCallback();
    ConnectedDevice connectedDevice =
        new ConnectedDevice(
            UUID.randomUUID().toString(),
            /* deviceName = */ null,
            /* belongsToActiveUser = */ false,
            /* hasSecureChannel = */ false);
    binder.registerDeviceCallback(connectedDevice, recipientId, deviceCallback);
    verify(mockConnectedDeviceManager)
        .registerDeviceCallback(
            refEq(connectedDevice), refEq(recipientId.getUuid()),
            any(DeviceCallback.class), any(Executor.class));
  }

  @Test
  public void unregisterDeviceCallback_mirrorsConnectedDeviceManager() {
    IDeviceCallback deviceCallback = createDeviceCallback();
    ConnectedDevice connectedDevice =
        new ConnectedDevice(
            UUID.randomUUID().toString(),
            /* deviceName = */ null,
            /* belongsToActiveUser = */ false,
            /* hasSecureChannel = */ false);
    binder.registerDeviceCallback(connectedDevice, recipientId, deviceCallback);
    binder.unregisterDeviceCallback(connectedDevice, recipientId, deviceCallback);
    verify(mockConnectedDeviceManager)
        .unregisterDeviceCallback(
            refEq(connectedDevice),
            refEq(recipientId.getUuid()),
            any(DeviceCallback.class));
  }

  @Test
  public void registerOnLogRequestedListener_mirrorsLoggingManager() {
    IOnLogRequestedListener listener = createOnLogRequestedListener();
    int testLoggerId = 1;
    binder.registerOnLogRequestedListener(testLoggerId, listener);
    verify(mockLoggingManager)
        .addOnLogRequestedListener(
            eq(testLoggerId), any(OnLogRequestedListener.class), any(Executor.class));
  }

  @Test
  public void unregisterOnLogRequestedListener_mirrorsLoggingManager() {
    IOnLogRequestedListener listener = createOnLogRequestedListener();
    int testLoggerId = 1;
    binder.registerOnLogRequestedListener(testLoggerId, listener);
    binder.unregisterOnLogRequestedListener(testLoggerId, listener);
    verify(mockLoggingManager)
        .removeOnLogRequestedListener(eq(testLoggerId), any(OnLogRequestedListener.class));
  }

  @Test
  public void sendMessageSecurely_mirrorsConnectedDeviceManager() {
    ConnectedDevice connectedDevice =
        new ConnectedDevice(
            UUID.randomUUID().toString(),
            /* deviceName = */ null,
            /* belongsToActiveUser = */ false,
            /* hasSecureChannel = */ true);
    byte[] message = ByteUtils.randomBytes(10);
    binder.sendMessageSecurely(connectedDevice, recipientId, message);
    verify(mockConnectedDeviceManager)
        .sendMessageSecurely(
            refEq(connectedDevice),
            refEq(recipientId.getUuid()),
            refEq(message));
  }

  @Test
  public void sendMessageUnsecurely_mirrorsConnectedDeviceManager() {
    ConnectedDevice connectedDevice =
        new ConnectedDevice(
            UUID.randomUUID().toString(),
            /* deviceName = */ null,
            /* belongsToActiveUser = */ false,
            /* hasSecureChannel = */ false);
    byte[] message = ByteUtils.randomBytes(10);
    binder.sendMessageUnsecurely(connectedDevice, recipientId, message);
    verify(mockConnectedDeviceManager)
        .sendMessageUnsecurely(
            refEq(connectedDevice),
            refEq(recipientId.getUuid()),
            refEq(message));
  }

  @Test
  public void registerDeviceAssociationCallback_mirrorsConnectedDeviceManager() {
    IDeviceAssociationCallback associationCallback =
        createDeviceAssociationCallback();
    binder.registerDeviceAssociationCallback(associationCallback);
    verify(mockConnectedDeviceManager)
        .registerDeviceAssociationCallback(
            any(DeviceAssociationCallback.class), any(Executor.class));
  }

  @Test
  public void unregisterDeviceAssociationCallback_mirrorsConnectedDeviceManager() {
    IDeviceAssociationCallback associationCallback =
        createDeviceAssociationCallback();
    binder.registerDeviceAssociationCallback(associationCallback);
    binder.unregisterDeviceAssociationCallback(associationCallback);
    verify(mockConnectedDeviceManager)
        .unregisterDeviceAssociationCallback(any(DeviceAssociationCallback.class));
  }

  @NonNull
  private static IConnectionCallback createConnectionCallback() {
    return spy(
        new IConnectionCallback.Stub() {
          @Override
          public void onDeviceConnected(ConnectedDevice connectedDevice) {
          }

          @Override
          public void onDeviceDisconnected(ConnectedDevice connectedDevice) {
          }
        });
  }

  @NonNull
  private static IDeviceCallback createDeviceCallback() {
    return spy(
        new IDeviceCallback.Stub() {
          @Override
          public void onSecureChannelEstablished(ConnectedDevice connectedDevice) {
          }

          @Override
          public void onMessageReceived(ConnectedDevice connectedDevice, byte[] message) {
          }

          @Override
          public void onDeviceError(ConnectedDevice connectedDevice, int error) {
          }
        });
  }

  @NonNull
  private static IDeviceAssociationCallback createDeviceAssociationCallback() {
    return spy(
        new IDeviceAssociationCallback.Stub() {
          @Override
          public void onAssociatedDeviceAdded(AssociatedDevice device) {
          }

          @Override
          public void onAssociatedDeviceRemoved(AssociatedDevice device) {
          }

          @Override
          public void onAssociatedDeviceUpdated(AssociatedDevice device) {
          }
        });
  }

  @NonNull
  private static IOnLogRequestedListener createOnLogRequestedListener() {
    return spy(
        new IOnLogRequestedListener.Stub() {
          @Override
          public void onLogRecordsRequested() {}
        });
  }
}