package com.docotel.esimpns.service.messaging;

import android.app.ActivityManager;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.BitmapFactory;
import android.media.RingtoneManager;
import android.net.ConnectivityManager;
import android.net.Uri;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.support.v7.app.NotificationCompat;
import android.text.TextUtils;
import android.util.Log;

import com.docotel.esimpns.MainApplication;
import com.docotel.esimpns.R;
import com.docotel.esimpns.helper.LoggerHelper;
import com.docotel.esimpns.helper.NetworkHelper;
import com.docotel.esimpns.helper.PreferenceHelper;
import com.docotel.esimpns.model.form.ChatForm;
import com.docotel.esimpns.model.form.ContactForm;
import com.docotel.esimpns.model.response.contact.DataContact;
import com.docotel.esimpns.model.response.contact.FriendData;
import com.docotel.esimpns.modul.main.MainActivity;
import com.docotel.esimpns.modul.messaging.conversation.ConversationActivity;
import com.docotel.esimpns.setting.MessagingSetting;
import com.docotel.esimpns.util.SimpleObserver;

import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Stanza;
import org.jivesoftware.smackx.receipts.DeliveryReceiptManager;
import org.jivesoftware.smackx.receipts.ReceiptReceivedListener;

import java.util.ArrayList;
import java.util.List;

import rx.Observable;

import static android.net.ConnectivityManager.CONNECTIVITY_ACTION;
import static com.docotel.esimpns.helper.PreferenceHelper.CURRENT_ACTIVE_CHAT_CONTACT;
import static com.docotel.esimpns.helper.PreferenceHelper.LOGIN_XMPP;

/**
 * Created by Docotel on 7/6/2017.
 */

public class MessagingService extends Service implements MessagingServiceView {

    public static final String ASK_FOR_LOCATION = "[DOCOTEL-ASK]";
    public static final String ALLOW_YOUR_LOCATION = "[DOCOTEL-ALLOW]";
    public static final String DENY_YOUR_LOCATION = "[DOCOTEL-DENY]";

    public static final String TRIGGER_CONVERSATION = "com.doco.trigger.action.CONVERSATION";
    public static final String TRIGGER_CONVERSATION_KEY = "com.doco.trigger.CONVERSATION.KEY";
    public static final int INCOMING_NOTIF_ID = 864;

    public static List<ContactForm> listContact;
    public static MessagingSetting messagingSetting;
    public static DeliveryReceiptManager deliveryReceiptManager;

    private Handler worker;
    private PreferenceHelper preferences;

    private String message;
    private String email;
    private String typeOfMessage;
    private String updateParams;
    private boolean isRunAgain = false;

    private MessagingServiceRequestImpl request;

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

    @Override
    public void onCreate() {
        super.onCreate();
        listContact = new ArrayList<>();
        request = new MessagingServiceRequestImpl(this);
        request.setBaseView(this);

        initDependencies();
        registerReceiver();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        updatePrefference(PreferenceHelper.INCOMING_CHAT_CONTACT_ID, "");
        initMessageSetting();
        initDeliveryMessageRecepient();

        if (intent != null) {
            message = getExtraFromIntent(intent, ".message");
            email = getExtraFromIntent(intent, ".email");
            typeOfMessage = getExtraFromIntent(intent, ".typeOfMessage");
            updateParams = getExtraFromIntent(intent, ".updateParams");

            updateMessageSetting(email, message);
            connect();
        }

        runHandler();

        return Service.START_STICKY;
    }

    private void registerReceiver() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        this.registerReceiver(wifiReceiver, filter);
    }

    private BroadcastReceiver wifiReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            switch (intent.getAction()) {
                case CONNECTIVITY_ACTION:
                    if (NetworkHelper.isConnected(context)) {
                        if (!isRunAgain) {
                            sendPendingMessage();
                            isRunAgain = true;
                            request.onRestartService();
                        }
                    } else {
                        isRunAgain = false;
                    }
                    break;
            }
        }
    };

    private void sendPendingMessage() {
        List<ChatForm> chats = new ChatForm(this).getListPendingChat("0");
        if (!chats.isEmpty()) {
            for (int i = 0; i < chats.size(); i++) {
                String msgToLocalDB = getMessageBy(chats.get(i).getType(), chats.get(i).getMessage());
                messagingSetting.sendPendingMessage(chats.get(i), msgToLocalDB);
            }
        }
    }

    private void initDependencies() {
        preferences = new PreferenceHelper(getApplicationContext());
    }

    private void initHandler() {
        HandlerThread workerThread = new HandlerThread("ConnectionService - WorkerThread");
        workerThread.start();
        worker = new Handler(workerThread.getLooper());
    }

    private void initMessageSetting() {
        System.out.println("MessagingService.initMessageSetting");
        messagingSetting = new MessagingSetting(getApplicationContext());
        messagingSetting.initMessaging();

        messagingSetting.setMessagesListener(new MessagingSetting.MessagesListener() {

            @Override
            public void OnReceiveMessages(Message message) {
                syncContact();
                String firstLogin = getPrefference(PreferenceHelper.IS_LOGIN);
                if (TextUtils.isEmpty(firstLogin)) {
                    disconnect();
                    return;
                }

                if (listContact == null)
                    return;

                ContactForm contact = getContactForm(listContact, message);
                if (contact == null)
                    return;

                if (TextUtils.isEmpty(message.getBody()))
                    return;

                if (!TextUtils.isEmpty(contact.getUsernameOpenFire())) {
                    sendResult(contact, message.getBody(), message.getStanzaId());
                    updatePrefference(PreferenceHelper.INCOMING_CHAT_CONTACT_ID, contact.getUsernameOpenFire());

                    Notification notification = createNotification(contact, message).build();
                    notifyUser(contact, INCOMING_NOTIF_ID, notification);
                }
            }
        });
    }

    private ContactForm getContactForm(List<ContactForm> listContact, Message message) {
        return ContactForm.getContactByUsernameOpenFire(listContact, message.getFrom());
    }

    private void connect() {
        if (messagingSetting != null)
            messagingSetting.connectToMessaging();
    }

    private void disconnect() {
        if (messagingSetting != null)
            messagingSetting.disconnect();
    }

    private void initDeliveryMessageRecepient() {
        deliveryReceiptManager = getDeliveryReceiptManager();
        deliveryReceiptManager.addReceiptReceivedListener(new ReceiptReceivedListener() {
            @Override
            public void onReceiptReceived(String fromJid, String toJid, String receiptId, Stanza receipt) {
                LoggerHelper.error("RECEIPT RECEIVED" + "From JID : " + fromJid + ", To JID : " + toJid + ", Receipt ID : " + receiptId + ", receipt : " + receiptId);

                String contactId = getContactId(fromJid);
                List<ChatForm> listChat = getListOfChat(contactId);
                updateDatabaseOfChatForm(listChat, receiptId);
                broadCastNow("");
            }
        });
    }

    private DeliveryReceiptManager getDeliveryReceiptManager() {
        return messagingSetting.getDeliveryReceiptManager();
    }

    private void updateDatabaseOfChatForm(List<ChatForm> chatForms, String receiptId) {
        for (ChatForm chat : chatForms) {
            if (chat.getMessageId().equalsIgnoreCase(receiptId)) {
                chat.updateByQuery("messageId", receiptId, "isReceived", "1");
            }
        }
    }

    private String getContactId(String fromJid) {
        String[] username = fromJid.split("@");
        return username[0];
    }

    private List<ChatForm> getListOfChat(String fromContactId) {
        return new ChatForm().getChatByContactId(fromContactId);
    }

    private NotificationCompat.Builder createNotification(ContactForm contact, Message message) {
        Uri alarmSound = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        NotificationCompat.Builder builder = new NotificationCompat.Builder(MessagingService.this);
        builder.setSmallIcon(R.drawable.ic_notif_chat);
        builder.setContentTitle("Anda mendapat pesan baru");
        builder.setContentText("Pesan dari : " + contact.getName());
        builder.setLargeIcon(BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher));
        if (alarmSound != null) {
            builder.setSound(alarmSound);
        }
        PendingIntent resultPendingIntent = getPendingIntent(contact, message);

        builder.setContentIntent(resultPendingIntent);
        builder.setAutoCancel(true);

        return builder;
    }

    private PendingIntent getPendingIntent(ContactForm contact, Message message) {
        Intent resultIntent = new Intent(MessagingService.this, ConversationActivity.class);
        resultIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
        resultIntent.putExtra(ConversationActivity.class.getSimpleName() + ".usernameOpenFire", contact.getUsernameOpenFire());
        resultIntent.putExtra(ConversationActivity.class.getSimpleName() + ".message", message.getBody());
        PendingIntent resultPendingIntent = PendingIntent.getActivity(MessagingService.this,
                0, resultIntent, PendingIntent.FLAG_UPDATE_CURRENT);

        return resultPendingIntent;
    }

    private void notifyUser(ContactForm contact, int notifId, Notification notification) {
        ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
        List<ActivityManager.RunningTaskInfo> runningTaskInfo = manager.getRunningTasks(1);
        ComponentName componentInfo = runningTaskInfo.get(0).topActivity;
        String currentActiveChat = preferences.getString(CURRENT_ACTIVE_CHAT_CONTACT);

        boolean isAbleToNotify = !ConversationActivity.CONVERSATION_CLASS_NAME.equalsIgnoreCase(componentInfo.getClassName())
                || !contact.getUsernameOpenFire().equalsIgnoreCase(currentActiveChat);

        if (isAbleToNotify) {
            NotificationManager mNotifyMgr = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
            mNotifyMgr.notify(notifId, notification);
        }
    }

    private void sendResult(ContactForm contact, String message, String messageId) {
        String msg = getMessageType(message);
        saveChatForm(contact, msg, messageId);
        broadCastNow(message);
    }

    private String getMessageType(String rawMessage) {
        String result = rawMessage;
        if (message.contains(ASK_FOR_LOCATION)) {
            result = message.substring(ASK_FOR_LOCATION.length() + 1);
        } else if (message.contains(DENY_YOUR_LOCATION)) {
            result = message.substring(DENY_YOUR_LOCATION.length() + 1);
        }
        return result;
    }

    private void saveChatForm(ContactForm contact, String message, String messageId) {
        new ChatForm(MainApplication.CONTEXT, contact.getUsernameOpenFire(), message, ChatForm.TYPE_RECEIVE, "", "", "1").save();
    }

    private void updatePrefference(String key, String object) {
        preferences.putString(key, object);
    }

    private String getPrefference(String key) {
        return preferences.getString(key);
    }

    private void broadCastNow(String message) {
        Intent intent = new Intent(TRIGGER_CONVERSATION);
        intent.putExtra(TRIGGER_CONVERSATION_KEY, message);
        sendBroadcast(intent);
        updatePrefference(PreferenceHelper.INCOMING_CHAT_MESSAGE, message);
    }

    private String getExtraFromIntent(Intent intent, String prefix) {
        return intent.getStringExtra(MessagingService.class.getSimpleName() + prefix);
    }

    private void updateMessageSetting(String email, String message) {
        if (messagingSetting == null)
            return;
        messagingSetting.setEmail(email);
        messagingSetting.setMessage(message);
    }

    private void loginChat(String username, String password) {
        if (messagingSetting == null)
            return;
        messagingSetting.loginChat(username, password);
    }

    private boolean isChatConnected() {
        return messagingSetting.isConnected();
    }

    private void runHandler() {
        String firstLogin = getPrefference(PreferenceHelper.IS_LOGIN);
        if (TextUtils.isEmpty(firstLogin)) {
            disconnect();
        }

        String user = getPrefference(LOGIN_XMPP);
        String password = getPrefference(PreferenceHelper.PASS_XMPP);
        boolean isProcessToChat = !messagingSetting.isConnected() && !TextUtils.isEmpty(user) && !TextUtils.isEmpty(password);

        if (isProcessToChat) {
            connect();
            loginChat(user, password);
        }

        if (isChatConnected()) {
            syncContact();

            boolean isProcessMessage = !TextUtils.isEmpty(message) && !TextUtils.isEmpty(user);
            if (isProcessMessage) {
                String msgToLocalDB = getMessageBy(typeOfMessage, message);
                String latlon = "0";
                if (typeOfMessage.equalsIgnoreCase(ALLOW_YOUR_LOCATION)) {
                    latlon = "1";
                }
                sendMessage(latlon, msgToLocalDB, updateParams);
            }
            fireMessageReceived();
        }
    }

    private void sendMessage(String latitudeLongitude, String messageToLocalDb, String updateParams) {
        messagingSetting.sendMessage(message, email, latitudeLongitude, messageToLocalDb, getApplicationContext(), updateParams);
    }

    private void fireMessageReceived() {
        messagingSetting.receiveMessage();
    }

    private String getMessageBy(String typeOfMessage, String defaultMessage) {
        if (typeOfMessage.equalsIgnoreCase(ASK_FOR_LOCATION)) {
            return "You ask to his/her location";
        } else if (typeOfMessage.equalsIgnoreCase(ALLOW_YOUR_LOCATION)) {
            return "You allow to be tracked";
        } else if (typeOfMessage.equalsIgnoreCase(DENY_YOUR_LOCATION)) {
            return "You deny to be tracked";
        } else {
            return defaultMessage;
        }
    }

    private synchronized void syncContact() {
        String userId = preferences.getString(PreferenceHelper.USER_ID);
        if (!TextUtils.isEmpty(userId)) {
            if (listContact.size() <= 0) {
                getSyncContactList(userId);
            }
        }
    }

    private void getSyncContactList(String userId) {
        request.getSyncContactList(userId);
    }

    private void stopThis() {
        listContact.clear();
        messagingSetting.disconnect();
        unregisterReceiver(wifiReceiver);
        stopSelf();
    }

    @Override
    public void onDestroy() {
        Log.wtf("DESTROY", "GTALK SERVICE HAS BEEN DESTROYED !");
        stopThis();
        super.onDestroy();
    }

    @Override
    public void onSuccessRequestContactList(DataContact contactList) {
        List<FriendData> listUsers = contactList.getFriendData();
        clearContact();

        Observable.just(listUsers)
                .flatMap(friendDatas -> Observable.from(friendDatas))
                .flatMap(friend -> getContact(friend))
                .subscribe(new SimpleObserver<ContactForm>() {
                    @Override
                    public void onNext(ContactForm contactForm) {
                        addContact(contactForm);
                    }
                });
    }

    private void clearContact() {
        listContact.clear();
    }

    private void addContact(ContactForm contact) {
        listContact.add(contact);
    }

    private Observable<ContactForm> getContact(FriendData friendData) {
        ContactForm c = new ContactForm(MainActivity.CONTEXT);
        c.setName(friendData.getName());
        c.setUserIdFriend(friendData.getUserIdFriend());
        c.setJid(friendData.getJid());
        c.setUsernameOpenFire(friendData.getUserNameOpenfireFriend());
        return Observable.just(c);
    }

    @Override
    public void onFailure(String message) {
        LoggerHelper.error(message);
    }
}