package com.bs.pulse.chat;

import android.content.Context;
import android.util.Log;

import com.bs.pulse.utils.CustomLogger;
import com.bs.pulse.utils.DateUtil;
import com.bs.pulse.videoCall.MessageAdapter;
import com.bs.pulse.videoCall.model.MessageBody;
import com.bs.pulse.videoCall.model.PulseMessage;
import com.google.gson.Gson;
import com.twilio.chat.CallbackListener;
import com.twilio.chat.Channel;
import com.twilio.chat.ChannelListener;
import com.twilio.chat.ChatClient;
import com.twilio.chat.ErrorInfo;
import com.twilio.chat.Member;
import com.twilio.chat.Message;
import com.twilio.chat.StatusListener;

import static com.bs.pulse.videoCall.MessageAdapter.DIRECTION_INCOMING;
import static com.bs.pulse.videoCall.MessageAdapter.DIRECTION_OUTGOING;

public class TwilioChatImplementation implements ChatContract {

    private String TAG = "twilio-chat";
    private ChatClient mChatClient;

    private Context context;
    private String myUserId;
    private Channel mGeneralChannel;
    private String DEFAULT_CHANNEL_NAME = "n/a";
    private ChatCallback chatCallback;

    private boolean isSend = false;

    @Override
    public void initialize(Context context, String myUserId, String channelName, String accessToken, ChatCallback chatCallback) {
        this.context = context;
        this.myUserId = myUserId;
        DEFAULT_CHANNEL_NAME = channelName;
        this.chatCallback = chatCallback;


        ChatClient.Properties.Builder builder = new ChatClient.Properties.Builder();
        ChatClient.Properties props = builder.createProperties();
        ChatClient.create(context, accessToken, props, mChatClientCallback);
    }

    @Override
    public void sendMessage(MessageBody messageBody) {

        isSend = true;

        if (mGeneralChannel != null) {

            Message.Options options = Message.options().withBody(new Gson().toJson(messageBody, MessageBody.class));

            mGeneralChannel.getMessages().sendMessage(options, new CallbackListener<Message>() {
                @Override
                public void onSuccess(Message message) {
                    Log.d("tag", "send message " + message.getMessageBody());
                }
            });
        } else
            CustomLogger.ErrorLog("Channel is null");

    }

    private CallbackListener<ChatClient> mChatClientCallback = new CallbackListener<ChatClient>() {

        @Override
        public void onSuccess(ChatClient chatClient) {
            mChatClient = chatClient;
            loadChannels();
            Log.d(TAG, "Success creating Twilio Chat Client");
        }

        @Override
        public void onError(ErrorInfo errorInfo) {
            Log.e(TAG, "Error creating Twilio Chat Client: " + errorInfo.getMessage());
        }
    };

    private void loadChannels() {
        mChatClient.getChannels().getChannel(DEFAULT_CHANNEL_NAME, new CallbackListener<Channel>() {
            @Override
            public void onSuccess(Channel channel) {

                if (channel != null) {
                    joinChannel(channel);
                } else {

                    mChatClient.getChannels().channelBuilder()
                            .withUniqueName(DEFAULT_CHANNEL_NAME)
                            .withFriendlyName(DEFAULT_CHANNEL_NAME)
                            .withType(Channel.ChannelType.PUBLIC)
                            .build(new CallbackListener<Channel>() {
                                @Override
                                public void onSuccess(Channel channel) {
                                    joinChannel(channel);
                                }
                            });
                }
            }

            @Override
            public void onError(ErrorInfo errorInfo) {
                Log.e(TAG, "Error retrieving channel: " + errorInfo.getMessage());

                mChatClient.getChannels().channelBuilder()
                        .withUniqueName(DEFAULT_CHANNEL_NAME)
                        .withFriendlyName(DEFAULT_CHANNEL_NAME)
                        .withType(Channel.ChannelType.PUBLIC)
                        .build(new CallbackListener<Channel>() {
                            @Override
                            public void onSuccess(Channel channel) {
                                joinChannel(channel);
                            }
                        });
            }

        });

    }

    private void joinChannel(final Channel channel) {

        channel.leave(new StatusListener() {
            @Override
            public void onSuccess() {

                channel.join(new StatusListener() {
                    @Override
                    public void onSuccess() {
                        Log.d(TAG, "Joined channel: " + channel.getUniqueName());

                        mGeneralChannel = channel;

                        mGeneralChannel.addListener(mDefaultChannelListener);
                        chatCallback.onChatJoinSuccess();
                    }

                    @Override
                    public void onError(ErrorInfo errorInfo) {
                        Log.e(TAG, "Error joining channel: " + errorInfo.getMessage());
                        chatCallback.onChatJoinFailed(errorInfo.getMessage());
                    }
                });
            }

            @Override
            public void onError(ErrorInfo errorInfo) {
                super.onError(errorInfo);
                Log.e(TAG, "Joining error: " + errorInfo.getMessage());

                channel.join(new StatusListener() {
                    @Override
                    public void onSuccess() {
                        Log.d(TAG, "Joined channel: " + channel.getUniqueName());

                        mGeneralChannel = channel;

                        mGeneralChannel.addListener(mDefaultChannelListener);
                        chatCallback.onChatJoinSuccess();
                    }

                    @Override
                    public void onError(ErrorInfo errorInfo) {
                        Log.e(TAG, "Error joining channel: " + errorInfo.getMessage());
                        chatCallback.onChatJoinFailed(errorInfo.getMessage());
                    }
                });
            }
        });

    }


    private ChannelListener mDefaultChannelListener = new ChannelListener() {

        @Override
        public void onMessageAdded(final Message message) {
            CustomLogger.Log("Message added: " + message.getMessageBody() + " is send " + isSend);

            String messageBody = message.getMessageBody();
            MessageBody messageBodyModel = new Gson().fromJson(messageBody, MessageBody.class);

            if (messageBodyModel.getKeyType().equalsIgnoreCase("video") && messageBodyModel.getKeyBodyText().equalsIgnoreCase("callReject")) {
                chatCallback.onOutgoingCallRejectedByOtherSideUser();
            } else {

                if (messageBodyModel.getKeyType().equalsIgnoreCase("chat")) {

                    PulseMessage pulseMessage =
                            new PulseMessage(messageBodyModel.getKeyMessageSenderName(),
                                    messageBodyModel.getKeyBodyText(),
                                    DateUtil.dateToStringWithTimeZoneGMT(message.getDateCreatedAsDate(), DateUtil.FORMAT_PULSE),
                                    messageBodyModel.getKeyMessageSenderId().equalsIgnoreCase(myUserId) ? DIRECTION_INCOMING : DIRECTION_OUTGOING);

                    if (isSend) {
                        isSend = false;
                        chatCallback.onMessageSent(pulseMessage);
                    } else {
                        chatCallback.onMessageReceived(pulseMessage);
                    }
                } else if (messageBodyModel.getKeyType().equalsIgnoreCase("camera")) {

                    CustomLogger.Log("camera type");

                    if (!isSend) {

                        CustomLogger.Log("Camera incoming");

                        if (messageBodyModel.getKeyBodyText().equalsIgnoreCase("on"))
                            chatCallback.onRemoteCameraStatusChanged(true);
                        else
                            chatCallback.onRemoteCameraStatusChanged(false);
                    }

                }
            }

        }

        @Override
        public void onMessageUpdated(Message message, Message.UpdateReason updateReason) {
            Log.d(TAG, "Message updated: " + message.getMessageBody());
        }

        @Override
        public void onMessageDeleted(Message message) {
            Log.d(TAG, "Message deleted");
        }

        @Override
        public void onMemberAdded(Member member) {
            Log.d(TAG, "Member added: " + member.getIdentity());
        }

        @Override
        public void onMemberUpdated(Member member, Member.UpdateReason updateReason) {
            Log.d(TAG, "Member updated: " + member.getIdentity());
        }

        @Override
        public void onMemberDeleted(Member member) {
            Log.d(TAG, "Member deleted: " + member.getIdentity());
        }

        @Override
        public void onTypingStarted(Channel channel, Member member) {
            Log.d(TAG, "Started Typing: " + member.getIdentity());
        }

        @Override
        public void onTypingEnded(Channel channel, Member member) {
            Log.d(TAG, "Ended Typing: " + member.getIdentity());
        }

        @Override
        public void onSynchronizationChanged(Channel channel) {

        }
    };
}