/*
 * Copyright (c) 2010-2019 Belledonne Communications SARL.
 *
 * This file is part of linphone-android
 * (see https://www.linphone.org).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
package org.linphone.call;

import android.Manifest;
import android.app.Dialog;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.os.SystemClock;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.TextureView;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.Chronometer;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.RelativeLayout;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.drawerlayout.widget.DrawerLayout;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import org.linphone.LinphoneContext;
import org.linphone.LinphoneManager;
import org.linphone.R;
import org.linphone.activities.LinphoneGenericActivity;
import org.linphone.chat.ChatActivity;
import org.linphone.compatibility.Compatibility;
import org.linphone.contacts.ContactsManager;
import org.linphone.contacts.ContactsUpdatedListener;
import org.linphone.contacts.LinphoneContact;
import org.linphone.contacts.views.ContactAvatar;
import org.linphone.core.Address;
import org.linphone.core.Call;
import org.linphone.core.ChatMessage;
import org.linphone.core.ChatRoom;
import org.linphone.core.Core;
import org.linphone.core.CoreListener;
import org.linphone.core.CoreListenerStub;
import org.linphone.core.tools.Log;
import org.linphone.dialer.DialerActivity;
import org.linphone.service.LinphoneService;
import org.linphone.settings.LinphonePreferences;
import org.linphone.utils.LinphoneUtils;

public class CallActivity extends LinphoneGenericActivity
        implements CallStatusBarFragment.StatsClikedListener,
                ContactsUpdatedListener,
                CallActivityInterface {
    private static final int SECONDS_BEFORE_HIDING_CONTROLS = 4000;
    private static final int SECONDS_BEFORE_DENYING_CALL_UPDATE = 30000;

    private static final int CAMERA_TO_TOGGLE_VIDEO = 0;
    private static final int MIC_TO_DISABLE_MUTE = 1;
    private static final int WRITE_EXTERNAL_STORAGE_FOR_RECORDING = 2;
    private static final int CAMERA_TO_ACCEPT_UPDATE = 3;
    private static final int ALL_PERMISSIONS = 4;

    private static class HideControlsRunnable implements Runnable {
        private WeakReference<CallActivity> mWeakCallActivity;

        public HideControlsRunnable(CallActivity activity) {
            mWeakCallActivity = new WeakReference<>(activity);
        }

        @Override
        public void run() {
            // Make sure that at the time this is executed this is still required
            if (!LinphoneContext.isReady()) return;

            Call call = LinphoneManager.getCore().getCurrentCall();
            if (call != null && call.getCurrentParams().videoEnabled()) {
                CallActivity activity = mWeakCallActivity.get();
                if (activity != null) activity.updateButtonsVisibility(false);
            }
        }
    }

    private final HideControlsRunnable mHideControlsRunnable = new HideControlsRunnable(this);

    private float mPreviewX, mPreviewY;
    private TextureView mLocalPreview, mRemoteVideo;
    private RelativeLayout mButtons,
            mActiveCalls,
            mContactAvatar,
            mActiveCallHeader,
            mConferenceHeader;
    private LinearLayout mCallsList, mCallPausedByRemote, mConferenceList;
    private ImageView mMicro, mSpeaker, mVideo;
    private ImageView mPause, mSwitchCamera, mRecordingInProgress;
    private ImageView mExtrasButtons, mAddCall, mTransferCall, mRecordCall, mConference;
    private ImageView mAudioRoute, mRouteEarpiece, mRouteSpeaker, mRouteBluetooth;
    private TextView mContactName, mMissedMessages;
    private ProgressBar mVideoInviteInProgress;
    private Chronometer mCallTimer;
    private CountDownTimer mCallUpdateCountDownTimer;
    private Dialog mCallUpdateDialog;

    private CallStatsFragment mStatsFragment;
    private Core mCore;
    private CoreListener mListener;
    private AndroidAudioManager mAudioManager;
    private VideoZoomHelper mZoomHelper;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        Compatibility.setShowWhenLocked(this, true);

        setContentView(R.layout.call);

        mLocalPreview = findViewById(R.id.local_preview_texture);
        mLocalPreview.setOnTouchListener(
                new View.OnTouchListener() {
                    @Override
                    public boolean onTouch(View v, MotionEvent event) {
                        return moveLocalPreview(v, event);
                    }
                });

        mRemoteVideo = findViewById(R.id.remote_video_texture);
        mRemoteVideo.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        makeButtonsVisibleTemporary();
                    }
                });

        mActiveCalls = findViewById(R.id.active_calls);
        mActiveCallHeader = findViewById(R.id.active_call);
        mCallPausedByRemote = findViewById(R.id.remote_pause);
        mCallsList = findViewById(R.id.calls_list);
        mConferenceList = findViewById(R.id.conference_list);
        mConferenceHeader = findViewById(R.id.conference_header);
        mButtons = findViewById(R.id.buttons);

        ImageView conferencePause = findViewById(R.id.conference_pause);
        conferencePause.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        LinphoneManager.getCallManager().pauseConference();
                        updateCallsList();
                    }
                });

        mContactName = findViewById(R.id.current_contact_name);
        mContactAvatar = findViewById(R.id.avatar_layout);
        mCallTimer = findViewById(R.id.current_call_timer);

        mVideoInviteInProgress = findViewById(R.id.video_in_progress);
        mVideo = findViewById(R.id.video);
        mVideo.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        if (checkAndRequestPermission(
                                Manifest.permission.CAMERA, CAMERA_TO_TOGGLE_VIDEO)) {
                            toggleVideo();
                        }
                    }
                });

        mMicro = findViewById(R.id.micro);
        mMicro.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        if (checkAndRequestPermission(
                                Manifest.permission.RECORD_AUDIO, MIC_TO_DISABLE_MUTE)) {
                            toggleMic();
                        }
                    }
                });

        mSpeaker = findViewById(R.id.speaker);
        mSpeaker.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        toggleSpeaker();
                    }
                });

        mAudioRoute = findViewById(R.id.audio_route);
        mAudioRoute.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        toggleAudioRouteButtons();
                    }
                });

        mRouteEarpiece = findViewById(R.id.route_earpiece);
        mRouteEarpiece.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        mAudioManager.routeAudioToEarPiece();
                        updateAudioRouteButtons();
                    }
                });

        mRouteSpeaker = findViewById(R.id.route_speaker);
        mRouteSpeaker.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        mAudioManager.routeAudioToSpeaker();
                        updateAudioRouteButtons();
                    }
                });

        mRouteBluetooth = findViewById(R.id.route_bluetooth);
        mRouteBluetooth.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        mAudioManager.routeAudioToBluetooth();
                        updateAudioRouteButtons();
                    }
                });

        mExtrasButtons = findViewById(R.id.options);
        mExtrasButtons.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        toggleExtrasButtons();
                    }
                });
        mExtrasButtons.setSelected(false);
        mExtrasButtons.setEnabled(!getResources().getBoolean(R.bool.disable_options_in_call));

        mAddCall = findViewById(R.id.add_call);
        mAddCall.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        goBackToDialer();
                    }
                });

        mTransferCall = findViewById(R.id.transfer);
        mTransferCall.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        goBackToDialerAndDisplayTransferButton();
                    }
                });
        mTransferCall.setEnabled(getResources().getBoolean(R.bool.allow_transfers));

        mConference = findViewById(R.id.conference);
        mConference.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        mCore.addAllToConference();
                    }
                });

        mRecordCall = findViewById(R.id.record_call);
        mRecordCall.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        if (checkAndRequestPermission(
                                Manifest.permission.WRITE_EXTERNAL_STORAGE,
                                WRITE_EXTERNAL_STORAGE_FOR_RECORDING)) {
                            toggleRecording();
                        }
                    }
                });

        ImageView numpadButton = findViewById(R.id.dialer);
        numpadButton.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        View numpad = findViewById(R.id.numpad);
                        boolean isNumpadVisible = numpad.getVisibility() == View.VISIBLE;
                        numpad.setVisibility(isNumpadVisible ? View.GONE : View.VISIBLE);
                        v.setSelected(!isNumpadVisible);
                    }
                });
        numpadButton.setSelected(false);

        ImageView hangUp = findViewById(R.id.hang_up);
        hangUp.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        LinphoneManager.getCallManager().terminateCurrentCallOrConferenceOrAll();
                    }
                });

        ImageView chat = findViewById(R.id.chat);
        chat.setEnabled(!getResources().getBoolean(R.bool.disable_chat));
        chat.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        goToChatList();
                    }
                });

        mPause = findViewById(R.id.pause);
        mPause.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        togglePause(mCore.getCurrentCall());
                    }
                });

        mSwitchCamera = findViewById(R.id.switchCamera);
        mSwitchCamera.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        LinphoneManager.getCallManager().switchCamera();
                    }
                });

        mRecordingInProgress = findViewById(R.id.recording);
        mRecordingInProgress.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        toggleRecording();
                    }
                });

        mMissedMessages = findViewById(R.id.missed_chats);

        DrawerLayout sideMenu = findViewById(R.id.side_menu);
        RelativeLayout sideMenuContent = findViewById(R.id.side_menu_content);
        mStatsFragment =
                (CallStatsFragment) getFragmentManager().findFragmentById(R.id.call_stats_fragment);
        mStatsFragment.setDrawer(sideMenu, sideMenuContent);

        CallStatusBarFragment statusBarFragment =
                (CallStatusBarFragment)
                        getFragmentManager().findFragmentById(R.id.status_bar_fragment);
        statusBarFragment.setStatsListener(this);

        mZoomHelper = new VideoZoomHelper(this, mRemoteVideo);

        mListener =
                new CoreListenerStub() {
                    @Override
                    public void onMessageReceived(Core core, ChatRoom cr, ChatMessage message) {
                        updateMissedChatCount();
                    }

                    @Override
                    public void onCallStateChanged(
                            Core core, Call call, Call.State state, String message) {
                        if (state == Call.State.End || state == Call.State.Released) {
                            if (core.getCallsNb() == 0) {
                                finish();
                            } else {
                                showVideoControls(false);
                            }
                        } else if (state == Call.State.PausedByRemote) {
                            if (core.getCurrentCall() != null) {
                                showVideoControls(false);
                                mCallPausedByRemote.setVisibility(View.VISIBLE);
                            }
                        } else if (state == Call.State.Pausing || state == Call.State.Paused) {
                            if (core.getCurrentCall() != null) {
                                showVideoControls(false);
                            }
                        } else if (state == Call.State.StreamsRunning) {
                            mCallPausedByRemote.setVisibility(View.GONE);

                            setCurrentCallContactInformation();
                            updateInterfaceDependingOnVideo();
                        } else if (state == Call.State.UpdatedByRemote) {
                            // If the correspondent asks for video while in audio call
                            boolean videoEnabled = LinphonePreferences.instance().isVideoEnabled();
                            if (!videoEnabled) {
                                // Video is disabled globally, don't even ask user
                                acceptCallUpdate(false);
                                return;
                            }

                            boolean showAcceptUpdateDialog =
                                    LinphoneManager.getCallManager()
                                            .shouldShowAcceptCallUpdateDialog(call);
                            if (showAcceptUpdateDialog) {
                                showAcceptCallUpdateDialog();
                                createTimerForDialog(SECONDS_BEFORE_DENYING_CALL_UPDATE);
                            }
                        }

                        updateButtons();
                        updateCallsList();
                    }
                };

        mCore = LinphoneManager.getCore();
        if (mCore != null) {
            boolean recordAudioPermissionGranted =
                    checkPermission(Manifest.permission.RECORD_AUDIO);
            if (!recordAudioPermissionGranted) {
                Log.w("[Call Activity] RECORD_AUDIO permission denied, muting microphone");
                mCore.enableMic(false);
            }

            Call call = mCore.getCurrentCall();
            boolean videoEnabled =
                    LinphonePreferences.instance().isVideoEnabled()
                            && call != null
                            && call.getCurrentParams().videoEnabled();

            if (videoEnabled) {
                mAudioManager = LinphoneManager.getAudioManager();
                mAudioManager.routeAudioToSpeaker();
                mSpeaker.setSelected(true);
            }
        }
    }

    @Override
    protected void onStart() {
        super.onStart();

        // This also must be done here in case of an outgoing call accepted
        // before user granted or denied permissions
        // or if an incoming call was answer from the notification
        checkAndRequestCallPermissions();

        mCore = LinphoneManager.getCore();
        if (mCore != null) {
            mCore.setNativeVideoWindowId(mRemoteVideo);
            mCore.setNativePreviewWindowId(mLocalPreview);
            mCore.addListener(mListener);
        }
    }

    @Override
    protected void onResume() {
        super.onResume();

        mAudioManager = LinphoneManager.getAudioManager();

        updateButtons();
        updateMissedChatCount();
        updateInterfaceDependingOnVideo();

        updateCallsList();
        ContactsManager.getInstance().addContactsListener(this);
        LinphoneManager.getCallManager().setCallInterface(this);

        if (mCore.getCallsNb() == 0) {
            Log.w("[Call Activity] Resuming but no call found...");
            finish();
        }

        if (LinphoneService.isReady()) LinphoneService.instance().destroyOverlay();
    }

    @Override
    protected void onPause() {
        ContactsManager.getInstance().removeContactsListener(this);
        LinphoneManager.getCallManager().setCallInterface(null);

        Core core = LinphoneManager.getCore();
        if (LinphonePreferences.instance().isOverlayEnabled()
                && core != null
                && core.getCurrentCall() != null) {
            Call call = core.getCurrentCall();
            if (call.getState() == Call.State.StreamsRunning) {
                // Prevent overlay creation if video call is paused by remote
                if (LinphoneService.isReady()) LinphoneService.instance().createOverlay();
            }
        }

        super.onPause();
    }

    @Override
    protected void onDestroy() {
        Core core = LinphoneManager.getCore();
        if (core != null) {
            core.removeListener(mListener);
            core.setNativeVideoWindowId(null);
            core.setNativePreviewWindowId(null);
        }

        if (mZoomHelper != null) {
            mZoomHelper.destroy();
            mZoomHelper = null;
        }
        if (mCallUpdateCountDownTimer != null) {
            mCallUpdateCountDownTimer.cancel();
            mCallUpdateCountDownTimer = null;
        }

        mCallTimer.stop();
        mCallTimer = null;

        mListener = null;
        mLocalPreview = null;
        mRemoteVideo = null;
        mStatsFragment = null;

        mButtons = null;
        mActiveCalls = null;
        mContactAvatar = null;
        mActiveCallHeader = null;
        mConferenceHeader = null;
        mCallsList = null;
        mCallPausedByRemote = null;
        mConferenceList = null;
        mMicro = null;
        mSpeaker = null;
        mVideo = null;
        mPause = null;
        mSwitchCamera = null;
        mRecordingInProgress = null;
        mExtrasButtons = null;
        mAddCall = null;
        mTransferCall = null;
        mRecordCall = null;
        mConference = null;
        mAudioRoute = null;
        mRouteEarpiece = null;
        mRouteSpeaker = null;
        mRouteBluetooth = null;
        mContactName = null;
        mMissedMessages = null;
        mVideoInviteInProgress = null;
        mCallUpdateDialog = null;

        super.onDestroy();
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (mAudioManager.onKeyVolumeAdjust(keyCode)) return true;
        return super.onKeyDown(keyCode, event);
    }

    @Override
    public void onStatsClicked() {
        if (mStatsFragment.isOpened()) {
            mStatsFragment.openOrCloseSideMenu(false, true);
        } else {
            mStatsFragment.openOrCloseSideMenu(true, true);
        }
    }

    @Override
    public void onRequestPermissionsResult(
            int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        // Permission not granted, won't change anything

        if (requestCode == ALL_PERMISSIONS) {
            for (int index = 0; index < permissions.length; index++) {
                int granted = grantResults[index];
                if (granted == PackageManager.PERMISSION_GRANTED) {
                    String permission = permissions[index];
                    if (Manifest.permission.RECORD_AUDIO.equals(permission)) {
                        toggleMic();
                    } else if (Manifest.permission.CAMERA.equals(permission)) {
                        LinphoneUtils.reloadVideoDevices();
                    }
                }
            }
        } else {
            if (grantResults[0] != PackageManager.PERMISSION_GRANTED) return;
            switch (requestCode) {
                case CAMERA_TO_TOGGLE_VIDEO:
                    LinphoneUtils.reloadVideoDevices();
                    toggleVideo();
                    break;
                case MIC_TO_DISABLE_MUTE:
                    toggleMic();
                    break;
                case WRITE_EXTERNAL_STORAGE_FOR_RECORDING:
                    toggleRecording();
                    break;
                case CAMERA_TO_ACCEPT_UPDATE:
                    LinphoneUtils.reloadVideoDevices();
                    acceptCallUpdate(true);
                    break;
            }
        }
    }

    private boolean checkPermission(String permission) {
        int granted = getPackageManager().checkPermission(permission, getPackageName());
        Log.i(
                "[Permission] "
                        + permission
                        + " permission is "
                        + (granted == PackageManager.PERMISSION_GRANTED ? "granted" : "denied"));
        return granted == PackageManager.PERMISSION_GRANTED;
    }

    private boolean checkAndRequestPermission(String permission, int result) {
        if (!checkPermission(permission)) {
            Log.i("[Permission] Asking for " + permission);
            ActivityCompat.requestPermissions(this, new String[] {permission}, result);
            return false;
        }
        return true;
    }

    private void checkAndRequestCallPermissions() {
        ArrayList<String> permissionsList = new ArrayList<>();

        int recordAudio =
                getPackageManager()
                        .checkPermission(Manifest.permission.RECORD_AUDIO, getPackageName());
        Log.i(
                "[Permission] Record audio permission is "
                        + (recordAudio == PackageManager.PERMISSION_GRANTED
                                ? "granted"
                                : "denied"));
        int camera =
                getPackageManager().checkPermission(Manifest.permission.CAMERA, getPackageName());
        Log.i(
                "[Permission] Camera permission is "
                        + (camera == PackageManager.PERMISSION_GRANTED ? "granted" : "denied"));

        int readPhoneState =
                getPackageManager()
                        .checkPermission(Manifest.permission.READ_PHONE_STATE, getPackageName());
        Log.i(
                "[Permission] Read phone state permission is "
                        + (camera == PackageManager.PERMISSION_GRANTED ? "granted" : "denied"));

        if (recordAudio != PackageManager.PERMISSION_GRANTED) {
            Log.i("[Permission] Asking for record audio");
            permissionsList.add(Manifest.permission.RECORD_AUDIO);
        }
        if (readPhoneState != PackageManager.PERMISSION_GRANTED) {
            Log.i("[Permission] Asking for read phone state");
            permissionsList.add(Manifest.permission.READ_PHONE_STATE);
        }

        Call call = mCore.getCurrentCall();
        if (LinphonePreferences.instance().shouldInitiateVideoCall()
                || (LinphonePreferences.instance().shouldAutomaticallyAcceptVideoRequests()
                        && call != null
                        && call.getRemoteParams().videoEnabled())) {
            if (camera != PackageManager.PERMISSION_GRANTED) {
                Log.i("[Permission] Asking for camera");
                permissionsList.add(Manifest.permission.CAMERA);
            }
        }

        if (permissionsList.size() > 0) {
            String[] permissions = new String[permissionsList.size()];
            permissions = permissionsList.toArray(permissions);
            ActivityCompat.requestPermissions(this, permissions, ALL_PERMISSIONS);
        }
    }

    @Override
    public void onContactsUpdated() {
        setCurrentCallContactInformation();
    }

    @Override
    public void onUserLeaveHint() {
        if (mCore == null) return;
        Call call = mCore.getCurrentCall();
        if (call == null) return;
        boolean videoEnabled =
                LinphonePreferences.instance().isVideoEnabled()
                        && call.getCurrentParams().videoEnabled();
        if (videoEnabled && getResources().getBoolean(R.bool.allow_pip_while_video_call)) {
            Compatibility.enterPipMode(this);
        }
    }

    @Override
    public void onPictureInPictureModeChanged(
            boolean isInPictureInPictureMode, Configuration newConfig) {
        if (isInPictureInPictureMode) {
            updateButtonsVisibility(false);
        }
    }

    @Override
    public void refreshInCallActions() {
        updateButtons();
    }

    @Override
    public void resetCallControlsHidingTimer() {
        LinphoneUtils.removeFromUIThreadDispatcher(mHideControlsRunnable);
        LinphoneUtils.dispatchOnUIThreadAfter(
                mHideControlsRunnable, SECONDS_BEFORE_HIDING_CONTROLS);
    }

    // BUTTONS

    private void updateAudioRouteButtons() {
        mRouteSpeaker.setSelected(mAudioManager.isAudioRoutedToSpeaker());
        mRouteBluetooth.setSelected(mAudioManager.isUsingBluetoothAudioRoute());
        mRouteEarpiece.setSelected(mAudioManager.isAudioRoutedToEarpiece());
    }

    private void updateButtons() {
        Call call = mCore.getCurrentCall();

        mMicro.setSelected(!mCore.micEnabled());

        mSpeaker.setSelected(mAudioManager.isAudioRoutedToSpeaker());

        updateAudioRouteButtons();

        boolean isBluetoothAvailable = mAudioManager.isBluetoothHeadsetConnected();
        mSpeaker.setVisibility(isBluetoothAvailable ? View.GONE : View.VISIBLE);
        mAudioRoute.setVisibility(isBluetoothAvailable ? View.VISIBLE : View.GONE);
        if (!isBluetoothAvailable) {
            mRouteBluetooth.setVisibility(View.GONE);
            mRouteSpeaker.setVisibility(View.GONE);
            mRouteEarpiece.setVisibility(View.GONE);
        }

        mVideo.setEnabled(
                LinphonePreferences.instance().isVideoEnabled()
                        && call != null
                        && !call.mediaInProgress());
        mVideo.setSelected(call != null && call.getCurrentParams().videoEnabled());
        mSwitchCamera.setVisibility(
                call != null && call.getCurrentParams().videoEnabled()
                        ? View.VISIBLE
                        : View.INVISIBLE);

        mPause.setEnabled(call != null && !call.mediaInProgress());

        mRecordCall.setSelected(call != null && call.isRecording());
        mRecordingInProgress.setVisibility(
                call != null && call.isRecording() ? View.VISIBLE : View.GONE);

        mConference.setEnabled(
                mCore.getCallsNb() > 1
                        && mCore.getCallsNb() > mCore.getConferenceSize()
                        && !mCore.soundResourcesLocked());
    }

    private void toggleMic() {
        mCore.enableMic(!mCore.micEnabled());
        mMicro.setSelected(!mCore.micEnabled());
    }

    private void toggleSpeaker() {
        if (mAudioManager.isAudioRoutedToSpeaker()) {
            mAudioManager.routeAudioToEarPiece();
        } else {
            mAudioManager.routeAudioToSpeaker();
        }
        mSpeaker.setSelected(mAudioManager.isAudioRoutedToSpeaker());
    }

    private void toggleVideo() {
        Call call = mCore.getCurrentCall();
        if (call == null) return;

        mVideoInviteInProgress.setVisibility(View.VISIBLE);
        mVideo.setEnabled(false);
        if (call.getCurrentParams().videoEnabled()) {
            LinphoneManager.getCallManager().removeVideo();
        } else {
            LinphoneManager.getCallManager().addVideo();
        }
    }

    private void togglePause(Call call) {
        if (call == null) return;

        if (call == mCore.getCurrentCall()) {
            call.pause();
            mPause.setSelected(true);
        } else if (call.getState() == Call.State.Paused) {
            call.resume();
            mPause.setSelected(false);
        }
    }

    private void toggleAudioRouteButtons() {
        mAudioRoute.setSelected(!mAudioRoute.isSelected());
        mRouteEarpiece.setVisibility(mAudioRoute.isSelected() ? View.VISIBLE : View.GONE);
        mRouteSpeaker.setVisibility(mAudioRoute.isSelected() ? View.VISIBLE : View.GONE);
        mRouteBluetooth.setVisibility(mAudioRoute.isSelected() ? View.VISIBLE : View.GONE);
    }

    private void toggleExtrasButtons() {
        mExtrasButtons.setSelected(!mExtrasButtons.isSelected());
        mAddCall.setVisibility(mExtrasButtons.isSelected() ? View.VISIBLE : View.GONE);
        mTransferCall.setVisibility(mExtrasButtons.isSelected() ? View.VISIBLE : View.GONE);
        mRecordCall.setVisibility(mExtrasButtons.isSelected() ? View.VISIBLE : View.GONE);
        mConference.setVisibility(mExtrasButtons.isSelected() ? View.VISIBLE : View.GONE);
    }

    private void toggleRecording() {
        Call call = mCore.getCurrentCall();
        if (call == null) return;

        if (call.isRecording()) {
            call.stopRecording();
        } else {
            call.startRecording();
        }
        mRecordCall.setSelected(call.isRecording());
        mRecordingInProgress.setVisibility(call.isRecording() ? View.VISIBLE : View.INVISIBLE);
    }

    private void updateMissedChatCount() {
        int count = 0;
        if (mCore != null) {
            count = mCore.getUnreadChatMessageCountFromActiveLocals();
        }

        if (count > 0) {
            mMissedMessages.setText(String.valueOf(count));
            mMissedMessages.setVisibility(View.VISIBLE);
        } else {
            mMissedMessages.clearAnimation();
            mMissedMessages.setVisibility(View.GONE);
        }
    }

    private void updateButtonsVisibility(boolean visible) {
        findViewById(R.id.status_bar_fragment).setVisibility(visible ? View.VISIBLE : View.GONE);
        if (mActiveCalls != null) mActiveCalls.setVisibility(visible ? View.VISIBLE : View.GONE);
        if (mButtons != null) mButtons.setVisibility(visible ? View.VISIBLE : View.GONE);
    }

    private void makeButtonsVisibleTemporary() {
        updateButtonsVisibility(true);
        resetCallControlsHidingTimer();
    }

    // VIDEO RELATED

    private void showVideoControls(boolean videoEnabled) {
        mContactAvatar.setVisibility(videoEnabled ? View.GONE : View.VISIBLE);
        mRemoteVideo.setVisibility(videoEnabled ? View.VISIBLE : View.GONE);
        mLocalPreview.setVisibility(videoEnabled ? View.VISIBLE : View.GONE);
        mSwitchCamera.setVisibility(videoEnabled ? View.VISIBLE : View.INVISIBLE);
        updateButtonsVisibility(!videoEnabled);
        mVideo.setSelected(videoEnabled);
        LinphoneManager.getInstance().enableProximitySensing(!videoEnabled);

        if (!videoEnabled) {
            LinphoneUtils.removeFromUIThreadDispatcher(mHideControlsRunnable);
        }
    }

    private void updateInterfaceDependingOnVideo() {
        Call call = mCore.getCurrentCall();
        if (call == null) {
            showVideoControls(false);
            return;
        }

        mVideoInviteInProgress.setVisibility(View.GONE);
        mVideo.setEnabled(
                LinphonePreferences.instance().isVideoEnabled()
                        && call != null
                        && !call.mediaInProgress());

        boolean videoEnabled =
                LinphonePreferences.instance().isVideoEnabled()
                        && call != null
                        && call.getCurrentParams().videoEnabled();
        showVideoControls(videoEnabled);
    }

    private boolean moveLocalPreview(View view, MotionEvent motionEvent) {
        switch (motionEvent.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mPreviewX = view.getX() - motionEvent.getRawX();
                mPreviewY = view.getY() - motionEvent.getRawY();
                break;

            case MotionEvent.ACTION_MOVE:
                view.animate()
                        .x(motionEvent.getRawX() + mPreviewX)
                        .y(motionEvent.getRawY() + mPreviewY)
                        .setDuration(0)
                        .start();
                break;
            default:
                return false;
        }
        return true;
    }

    // NAVIGATION

    private void goBackToDialer() {
        Intent intent = new Intent();
        intent.setClass(this, DialerActivity.class);
        intent.putExtra("isTransfer", false);
        intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION | Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
        startActivity(intent);
    }

    private void goBackToDialerAndDisplayTransferButton() {
        Intent intent = new Intent();
        intent.setClass(this, DialerActivity.class);
        intent.putExtra("isTransfer", true);
        intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION | Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
        startActivity(intent);
    }

    private void goToChatList() {
        Intent intent = new Intent();
        intent.setClass(this, ChatActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION | Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
        startActivity(intent);
    }

    // CALL UPDATE

    private void createTimerForDialog(long time) {
        mCallUpdateCountDownTimer =
                new CountDownTimer(time, 1000) {
                    public void onTick(long millisUntilFinished) {}

                    public void onFinish() {
                        if (mCallUpdateDialog != null) {
                            mCallUpdateDialog.dismiss();
                            mCallUpdateDialog = null;
                        }
                        acceptCallUpdate(false);
                    }
                }.start();
    }

    private void acceptCallUpdate(boolean accept) {
        if (mCallUpdateCountDownTimer != null) {
            mCallUpdateCountDownTimer.cancel();
        }
        LinphoneManager.getCallManager().acceptCallUpdate(accept);
    }

    private void showAcceptCallUpdateDialog() {
        mCallUpdateDialog = new Dialog(this);
        mCallUpdateDialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
        mCallUpdateDialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);
        mCallUpdateDialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
        mCallUpdateDialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        Drawable d = new ColorDrawable(ContextCompat.getColor(this, R.color.dark_grey_color));
        d.setAlpha(200);
        mCallUpdateDialog.setContentView(R.layout.dialog);
        mCallUpdateDialog
                .getWindow()
                .setLayout(
                        WindowManager.LayoutParams.MATCH_PARENT,
                        WindowManager.LayoutParams.MATCH_PARENT);
        mCallUpdateDialog.getWindow().setBackgroundDrawable(d);

        TextView customText = mCallUpdateDialog.findViewById(R.id.dialog_message);
        customText.setText(getResources().getString(R.string.add_video_dialog));
        mCallUpdateDialog.findViewById(R.id.dialog_delete_button).setVisibility(View.GONE);
        Button accept = mCallUpdateDialog.findViewById(R.id.dialog_ok_button);
        accept.setVisibility(View.VISIBLE);
        accept.setText(R.string.accept);
        Button cancel = mCallUpdateDialog.findViewById(R.id.dialog_cancel_button);
        cancel.setText(R.string.decline);

        accept.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        if (checkPermission(Manifest.permission.CAMERA)) {
                            acceptCallUpdate(true);
                        } else {
                            checkAndRequestPermission(
                                    Manifest.permission.CAMERA, CAMERA_TO_ACCEPT_UPDATE);
                        }
                        mCallUpdateDialog.dismiss();
                        mCallUpdateDialog = null;
                    }
                });

        cancel.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        acceptCallUpdate(false);
                        mCallUpdateDialog.dismiss();
                        mCallUpdateDialog = null;
                    }
                });
        mCallUpdateDialog.show();
    }

    // CONFERENCE

    private void displayConferenceCall(final Call call) {
        LinearLayout conferenceCallView =
                (LinearLayout)
                        LayoutInflater.from(this)
                                .inflate(R.layout.call_conference_cell, null, false);

        TextView contactNameView = conferenceCallView.findViewById(R.id.contact_name);
        LinphoneContact contact =
                ContactsManager.getInstance().findContactFromAddress(call.getRemoteAddress());
        if (contact != null) {
            ContactAvatar.displayAvatar(
                    contact, conferenceCallView.findViewById(R.id.avatar_layout), true);
            contactNameView.setText(contact.getFullName());
        } else {
            String displayName = LinphoneUtils.getAddressDisplayName(call.getRemoteAddress());
            ContactAvatar.displayAvatar(
                    displayName, conferenceCallView.findViewById(R.id.avatar_layout), true);
            contactNameView.setText(displayName);
        }

        Chronometer timer = conferenceCallView.findViewById(R.id.call_timer);
        timer.setBase(SystemClock.elapsedRealtime() - 1000 * call.getDuration());
        timer.start();

        ImageView removeFromConference =
                conferenceCallView.findViewById(R.id.remove_from_conference);
        removeFromConference.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        LinphoneManager.getCallManager().removeCallFromConference(call);
                    }
                });

        mConferenceList.addView(conferenceCallView);
    }

    private void displayPausedConference() {
        LinearLayout pausedConferenceView =
                (LinearLayout)
                        LayoutInflater.from(this)
                                .inflate(R.layout.call_conference_paused_cell, null, false);

        ImageView conferenceResume = pausedConferenceView.findViewById(R.id.conference_resume);
        conferenceResume.setSelected(true);
        conferenceResume.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        LinphoneManager.getCallManager().resumeConference();
                        updateCallsList();
                    }
                });

        mCallsList.addView(pausedConferenceView);
    }

    // OTHER

    private void updateCallsList() {
        Call currentCall = mCore.getCurrentCall();
        if (currentCall != null) {
            setCurrentCallContactInformation();
        }

        boolean callThatIsNotCurrentFound = false;
        boolean pausedConferenceDisplayed = false;
        boolean conferenceDisplayed = false;
        mCallsList.removeAllViews();
        mConferenceList.removeAllViews();

        for (Call call : mCore.getCalls()) {
            if (call != null && call.getConference() != null) {
                if (mCore.isInConference()) {
                    displayConferenceCall(call);
                    conferenceDisplayed = true;
                } else if (!pausedConferenceDisplayed) {
                    displayPausedConference();
                    pausedConferenceDisplayed = true;
                }
            } else if (call != null && call != currentCall) {
                Call.State state = call.getState();
                if (state == Call.State.Paused
                        || state == Call.State.PausedByRemote
                        || state == Call.State.Pausing) {
                    displayPausedCall(call);
                    callThatIsNotCurrentFound = true;
                }
            }
        }

        mCallsList.setVisibility(
                pausedConferenceDisplayed || callThatIsNotCurrentFound ? View.VISIBLE : View.GONE);
        mActiveCallHeader.setVisibility(
                currentCall != null && !conferenceDisplayed ? View.VISIBLE : View.GONE);
        mConferenceHeader.setVisibility(conferenceDisplayed ? View.VISIBLE : View.GONE);
        mConferenceList.setVisibility(mConferenceHeader.getVisibility());
    }

    private void displayPausedCall(final Call call) {
        LinearLayout callView =
                (LinearLayout)
                        LayoutInflater.from(this).inflate(R.layout.call_inactive_row, null, false);

        TextView contactName = callView.findViewById(R.id.contact_name);
        Address address = call.getRemoteAddress();
        LinphoneContact contact = ContactsManager.getInstance().findContactFromAddress(address);
        if (contact == null) {
            String displayName = LinphoneUtils.getAddressDisplayName(address);
            contactName.setText(displayName);
            ContactAvatar.displayAvatar(displayName, callView.findViewById(R.id.avatar_layout));
        } else {
            contactName.setText(contact.getFullName());
            ContactAvatar.displayAvatar(contact, callView.findViewById(R.id.avatar_layout));
        }

        Chronometer timer = callView.findViewById(R.id.call_timer);
        timer.setBase(SystemClock.elapsedRealtime() - 1000 * call.getDuration());
        timer.start();

        ImageView resumeCall = callView.findViewById(R.id.call_pause);
        resumeCall.setOnClickListener(
                new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        togglePause(call);
                    }
                });

        mCallsList.addView(callView);
    }

    private void updateCurrentCallTimer() {
        Call call = mCore.getCurrentCall();
        if (call == null) return;

        mCallTimer.setBase(SystemClock.elapsedRealtime() - 1000 * call.getDuration());
        mCallTimer.start();
    }

    private void setCurrentCallContactInformation() {
        updateCurrentCallTimer();

        Call call = mCore.getCurrentCall();
        if (call == null) return;

        LinphoneContact contact =
                ContactsManager.getInstance().findContactFromAddress(call.getRemoteAddress());
        if (contact != null) {
            ContactAvatar.displayAvatar(contact, mContactAvatar, true);
            mContactName.setText(contact.getFullName());
        } else {
            String displayName = LinphoneUtils.getAddressDisplayName(call.getRemoteAddress());
            ContactAvatar.displayAvatar(displayName, mContactAvatar, true);
            mContactName.setText(displayName);
        }
    }
}