package com.brainstation.revera.common.service;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

import com.brainstation.revera.common.App;
import com.brainstation.revera.common.Constants;
import com.brainstation.revera.common.database.AppDatabase;
import com.brainstation.revera.common.session.Session;
import com.brainstation.revera.feature.videocall.VideoCallActivity;
import com.sinch.android.rtc.AudioController;
import com.sinch.android.rtc.ClientRegistration;
import com.sinch.android.rtc.NotificationResult;
import com.sinch.android.rtc.Sinch;
import com.sinch.android.rtc.SinchClient;
import com.sinch.android.rtc.SinchClientListener;
import com.sinch.android.rtc.SinchError;
import com.sinch.android.rtc.calling.Call;
import com.sinch.android.rtc.calling.CallClient;
import com.sinch.android.rtc.calling.CallClientListener;
import com.sinch.android.rtc.messaging.MessageClientListener;
import com.sinch.android.rtc.messaging.WritableMessage;
import com.sinch.android.rtc.video.VideoController;
import com.sinch.android.rtc.video.VideoScalingType;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

import javax.inject.Inject;

public class SinchService extends Service {

    private static final String APP_KEY = "f75e178a-9ccb-4061-9de1-df71bd6c8525";
    private static final String APP_SECRET = "UB15mCMsFEKJG8WQmxBI1g==";
    private static final String ENVIRONMENT = "sandbox.sinch.com";

    static final String TAG = SinchService.class.getSimpleName();

    @Inject
    Session session;

    @Inject
    AppDatabase database;

    private SinchServiceInterface mSinchServiceInterface = new SinchServiceInterface();
    private SinchClient mSinchClient;

    private ClientStartListener mListener;

    private Map<String, String> callHeader;

    @Override
    public void onCreate() {
        super.onCreate();
        App.getInstance().getAppComponent().inject(this);
        attemptAutoStart();
    }

    @Override
    public void onDestroy() {
        if (mSinchClient != null && mSinchClient.isStarted()) {
            mSinchClient.terminate();
        }
        super.onDestroy();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mSinchServiceInterface;
    }

    private void attemptAutoStart() {
        startClient(session.getUser().getProfileName());
    }

    private void createClient(String username) {
        mSinchClient = Sinch.getSinchClientBuilder().context(getApplicationContext()).userId(username)
                .applicationKey(APP_KEY)
                .applicationSecret(APP_SECRET)
                .environmentHost(ENVIRONMENT).build();

        mSinchClient.setSupportCalling(true);
        mSinchClient.setSupportMessaging(true);
        mSinchClient.setSupportManagedPush(true);
        mSinchClient.startListeningOnActiveConnection();
        if (session.getUser().getUserType().equals(Constants.USER_TYPE_PATIENT)) {
            mSinchClient.setPushNotificationDisplayName(String.format("%s %s", session.getContact().getFirstName(), session.getContact().getLastName()));
        } else {
            mSinchClient.setPushNotificationDisplayName(database.reveraDoctorsDao().getReveraDoctorName(session.getContact().getId()));
        }

        mSinchClient.getVideoController().setResizeBehaviour(VideoScalingType.ASPECT_BALANCED);

        mSinchClient.addSinchClientListener(new MySinchClientListener());
        mSinchClient.getCallClient().addCallClientListener(new SinchCallClientListener());
    }

    private void startClient(String username) {
        if (mSinchClient == null) {
            createClient(username);
        }

        Log.d(TAG, "Starting SinchClient");
        mSinchClient.start();
    }

    private void stopClient() {
        if (mSinchClient != null) {
            mSinchClient.unregisterManagedPush();
            mSinchClient.stopListeningOnActiveConnection();
            mSinchClient.terminate();
            mSinchClient = null;
        }
    }

    private boolean isClientStarted() {
        return (mSinchClient != null && mSinchClient.isStarted());
    }

    private void sendMessage(String recipientUserId, String textBody) {
        if (isClientStarted()) {
            WritableMessage message = new WritableMessage(recipientUserId, textBody);
            mSinchClient.getMessageClient().send(message);
        }
    }

    private void addMessageClientListener(MessageClientListener listener) {
        if (mSinchClient != null) {
            mSinchClient.getMessageClient().addMessageClientListener(listener);
        }
    }

    private void removeMessageClientListener(MessageClientListener listener) {
        if (mSinchClient != null) {
            mSinchClient.getMessageClient().removeMessageClientListener(listener);
        }
    }

    public class SinchServiceInterface extends Binder {

        public void startClient(String userName) {
            SinchService.this.startClient(userName);
        }

        public void stopClient() {
            SinchService.this.stopClient();
        }

        public void retryStartAfterPermissionGranted() {
            SinchService.this.attemptAutoStart();
        }

        public boolean isClientStarted() {
            return SinchService.this.isClientStarted();
        }

        public void setStartListener(ClientStartListener listener) {
            mListener = listener;
        }

        public Call callUserVideo(String userId, Map<String, String> headers) {
            return mSinchClient.getCallClient().callUserVideo(userId, headers);
        }

        public String getUserName() {
            return mSinchClient != null ? mSinchClient.getLocalUserId() : "";
        }

        public Call getCall(String callId) {
            return mSinchClient.getCallClient().getCall(callId);
        }

        public VideoController getVideoController() {
            if (!isClientStarted()) {
                return null;
            }
            return mSinchClient.getVideoController();
        }

        public AudioController getAudioController() {
            if (!isClientStarted()) {
                return null;
            }
            return mSinchClient.getAudioController();
        }

        public void sendMessage(String recipientUserId, String textBody) {
            SinchService.this.sendMessage(recipientUserId, textBody);
        }

        public void addMessageClientListener(MessageClientListener listener) {
            SinchService.this.addMessageClientListener(listener);
        }

        public void removeMessageClientListener(MessageClientListener listener) {
            SinchService.this.removeMessageClientListener(listener);
        }

        public NotificationResult relayRemotePushNotificationPayload(final Map<String, String> payload, Map<String, String> callHeader) {
            if (mSinchClient == null) {
                createClient(session.getUser().getProfileName());
            }
            SinchService.this.callHeader = new HashMap<>(callHeader);
            return mSinchClient.relayRemotePushNotificationPayload(payload);
        }
    }

    public interface ClientStartListener {

        void onClientStarted();

        void onClientStartFailed(SinchError error);
    }

    private class MySinchClientListener implements SinchClientListener {

        @Override
        public void onClientStarted(SinchClient client) {
            Log.d(TAG, "SinchClient started");
            if (mListener != null) {
                mListener.onClientStarted();
            }
        }

        @Override
        public void onClientFailed(SinchClient client, SinchError error) {
            if (mListener != null) {
                mListener.onClientStartFailed(error);
            }
            mSinchClient.terminate();
            mSinchClient = null;
        }

        @Override
        public void onClientStopped(SinchClient client) {
            Log.d(TAG, "SinchClient stopped");
        }

        @Override
        public void onLogMessage(int level, String area, String message) {
            switch (level) {
                case Log.DEBUG:
                    Log.d(area, message);
                    break;
                case Log.ERROR:
                    Log.e(area, message);
                    break;
                case Log.INFO:
                    Log.i(area, message);
                    break;
                case Log.VERBOSE:
                    Log.v(area, message);
                    break;
                case Log.WARN:
                    Log.w(area, message);
                    break;
            }
        }

        @Override
        public void onRegistrationCredentialsRequired(SinchClient client, ClientRegistration clientRegistration) {
        }
    }

    private class SinchCallClientListener implements CallClientListener {

        @Override
        public void onIncomingCall(CallClient callClient, Call call) {
            Log.d(TAG, "Incoming call from " + call.getRemoteUserId());
            Map<String, String> headers = call.getHeaders();
            Log.d(TAG, "Call Hearders: " + headers);
            if (headers.isEmpty()) {
                headers = new HashMap<>(callHeader);
                Log.d(TAG, "Pushed Call Hearders: " + headers);
            }
            Intent intent = new Intent(SinchService.this, VideoCallActivity.class);
            intent.putExtra("EXTRA_CALL_ID", call.getCallId());
            intent.putExtra("EXTRA_INCOMING_CALL", true);
            intent.putExtra("EXTRA_APPOINTMENT_ID", Integer.parseInt(Objects.requireNonNull(headers.get("appointment_id"))));
            intent.putExtra("EXTRA_CALLER_NAME", Objects.requireNonNull(headers.get("caller_name")));
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            startActivity(intent);
        }
    }
}