package ua.kmd.transport.android;

import android.app.ActivityManager;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;

import com.google.gson.JsonArray;
import com.google.gson.JsonObject;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;

import ua.kmd.transport.IMessageListener;
import ua.kmd.transport.ITransport;
import ua.kmd.transport.ITransportListener;
import ua.kmd.transport.Logger;
import ua.kmd.transport.TransportMessage;
import ua.kmd.transport.Utils;

/**
 * Created by User on 26.04.2016.
 */
public class IntentTransport implements ITransport {
    private final long DEFAULT_PING_INTERVAL = 1000;
    private final long UPDATE_INTERVAL = 500;
    private final long DEFAULT_CONNECT_TIMEOUT = 4200;
    private final boolean DEFAULT_ALLOW_ANAUTHORIZED = true;
    final String ACTION_MESSAGE = "ua.kmd.transport.message";
    final String ACTION_PING = "ua.kmd.transport.ping";
    final String DATA_KEY = "DATA_KEY";

    private final Map<String, Date> onlineUsers = new HashMap<>();
    private final Map<String, Date> connectingUsers = new HashMap<>();
    private final List<String> users = new ArrayList<>();
    private final Timer pinger = new Timer();

    IMessageListener<TransportMessage> messageListener;
    private ITransportListener transportListener;

    private Context context;
    private long pingInterval;
    private long connectionTimeout;
    private boolean doPing;
    private boolean allowUnauthorized;
    String currentUser;
    static IntentTransport INSTANCE;

    private IPingEntityGetter pingEntityGetter;

    private long lastPing;
    private IntentReceiver receiver;

    public static synchronized IntentTransport instance() {
        return INSTANCE;
    }

    public IntentTransport(Context context, boolean receiverFromManifest) {
        this.context = context;
        INSTANCE = this;
        if (!receiverFromManifest) {
            IntentFilter intentFilter = new IntentFilter();
            intentFilter.addAction(ACTION_MESSAGE);
            intentFilter.addAction(ACTION_PING);
            receiver = new IntentReceiver();
            context.registerReceiver(receiver, intentFilter);
        }
    }

    public IntentTransport(Context context) {
        this(context, false);
    }

    private boolean load(JsonObject configJson)
    {
        try {
            Logger.INSTANCE.log("Loading IntentTransport config data");
            currentUser = configJson.get("user").getAsString();
            allowUnauthorized = configJson.has("allow_unauthorized") ? configJson.get("allow_unauthorized").getAsBoolean() : DEFAULT_ALLOW_ANAUTHORIZED;
            pingInterval = configJson.has("ping_interval") ? configJson.get("ping_interval").getAsLong() : DEFAULT_PING_INTERVAL;
            doPing = !configJson.has("ping") || configJson.get("ping").getAsBoolean();
            connectionTimeout = configJson.has("connection_timeout") ? configJson.get("connection_timeout").getAsLong() : DEFAULT_CONNECT_TIMEOUT;
            JsonArray userItems = configJson.get("users").getAsJsonArray();
            for (int i=0; i<userItems.size(); i++)
            {
                JsonObject obj = userItems.get(i).getAsJsonObject();
                users.add(obj.get("name").getAsString());
            }
            Logger.INSTANCE.log("IntentTransport config loaded successfully");
        } catch (Exception e) {
            Logger.INSTANCE.log("Error while loading IntentTransport config data");
            Logger.INSTANCE.log(e);
            return false;
        }
        return true;
    }

    @Override
    public synchronized void start(JsonObject config) {
        if (!load(config))
            return;

//        IntentFilter intentFilter = new IntentFilter();
//        intentFilter.addAction(ACTION_MESSAGE);
//        intentFilter.addAction(ACTION_PING);
//        context.registerReceiver(this, intentFilter);

        INSTANCE = this;

        if (pingInterval > 0) {
            pinger.schedule(new TimerTask() {
                @Override
                public synchronized void run() {
                    //synchronized (connectingUsers) {
                        Date now = new Date();
                        long elapsed;
                        Iterator<Map.Entry<String, Date>> iterator = onlineUsers.entrySet().iterator();
                        while (iterator.hasNext()) {
                            Map.Entry<String, Date> entry = iterator.next();
                            elapsed = now.getTime() - entry.getValue().getTime();
                            if (elapsed >= connectionTimeout) {
                                iterator.remove();
                                if (transportListener != null)
                                    transportListener.onDisconnected(entry.getKey());
                            }
                        }

                        elapsed = now.getTime() - lastPing;
                        if (doPing && elapsed >= pingInterval && !users.isEmpty()) {
                            ping(users.toArray(new String[users.size()]));
                            lastPing = now.getTime();
                        }

                        iterator = connectingUsers.entrySet().iterator();
                        while (iterator.hasNext()) {
                            Map.Entry<String, Date> entry = iterator.next();
                            elapsed = now.getTime() - entry.getValue().getTime();
                            if (!onlineUsers.containsKey(entry.getKey()) && elapsed >= connectionTimeout) {
                                iterator.remove();
                                if (transportListener != null)
                                    transportListener.onConnectionFailed(entry.getKey());
                            }
                        }
                    //}
                }
            }, 0, UPDATE_INTERVAL);
        }
    }

    public void setPingEntity(IPingEntityGetter pingEntityGetter) {
        this.pingEntityGetter = pingEntityGetter;
    }

    @Override
    public synchronized void stop() {
        //synchronized (connectingUsers) {
            if (receiver != null)
                context.unregisterReceiver(receiver);
            if (pinger != null)
                pinger.cancel();
            connectingUsers.clear();
            users.clear();
            onlineUsers.clear();
            INSTANCE = null;
        //}
    }

    @Override
    public synchronized void connect(String user) {
        //synchronized (connectingUsers) {
            if (!onlineUsers.containsKey(user) && !connectingUsers.containsKey(user)) {
                connectingUsers.put(user, new Date());
                ping(user);
            }
        //}
    }

    @Override
    public void commit(TransportMessage transportMessage) {
        if (transportMessage.receivers.isEmpty())
            return;
        byte[] msg = Utils.tryWriteObject(transportMessage);
        Intent intent = new Intent();
        intent.setAction(ACTION_MESSAGE);
        intent.putExtra(DATA_KEY, msg);
        context.sendBroadcast(intent);
    }

    @Override
    public void setListener(IMessageListener<TransportMessage> listener) {
        messageListener = listener;
    }

    @Override
    public void setListener(ITransportListener listener) {
        transportListener = listener;
    }

    @Override
    public String name() {
        return "Intent";
    }

    private void ping(String... users) {
        if (users.length == 0)
            return;
        TransportMessage pingMessage = new TransportMessage();
        pingMessage.sender = currentUser;
        pingMessage.receivers.addAll(Arrays.asList(users));
        if (pingEntityGetter == null) {
            byte[] msg = Utils.tryWriteObject(pingMessage);
            Intent intent = new Intent();
            intent.setAction(ACTION_PING);
            intent.putExtra(DATA_KEY, msg);
            context.sendBroadcast(intent);
        } else {
            Object pingEntity = pingEntityGetter.getPingEntity();
            pingMessage.className = pingEntity.getClass().getName();
            pingMessage.data = Utils.tryWriteObject(pingEntity);
            commit(pingMessage);
        }
    }

    boolean updateRespond(String user) {
        synchronized (connectingUsers) {
            if (!users.contains(user)) {
                if (allowUnauthorized)
                    users.add(user);
                else
                    return false;
            }
            if (connectingUsers.containsKey(user)) {
                connectingUsers.remove(user);
                if (transportListener != null)
                    transportListener.onConnected(user);
            }
            if (!onlineUsers.containsKey(user)) {
                onlineUsers.put(user, new Date());
                if (transportListener != null)
                    transportListener.onConnected(user);
            }
            else
                onlineUsers.get(user).setTime(new Date().getTime());
            return true;
        }
    }

    public boolean isAppInstalled(String packageName) {
        PackageManager pm = context.getPackageManager();
        boolean appInstalled;
        try {
            pm.getPackageInfo(packageName, PackageManager.GET_ACTIVITIES);
            appInstalled = true;
        }
        catch (PackageManager.NameNotFoundException e) {
            appInstalled = false;
        }
        return appInstalled ;
    }

    public boolean isAppRunning(String packageName) {
        if (!isAppInstalled(packageName))
            return false;
        ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningAppProcessInfo> procInfos = activityManager.getRunningAppProcesses();
        for(int i = 0; i < procInfos.size(); i++)
        {
            if(procInfos.get(i).processName.equals(packageName))
                return true;
        }
        return false;
    }

    public void launchApp(String packageName) {
        Intent launchIntent = context.getPackageManager()
                .getLaunchIntentForPackage(packageName);

//                  For proper behaviour we must setup our meteo app launch intent the same way the system does it
        launchIntent.setFlags(0);
        launchIntent.setPackage(null);
        launchIntent.setAction(Intent.ACTION_MAIN);
        launchIntent.addCategory(Intent.CATEGORY_LAUNCHER);

        launchIntent.setFlags(268435456);

        context.startActivity(launchIntent);
    }

    public void startService(String packageName) {
        Intent intent = context.getPackageManager().getLaunchIntentForPackage(packageName);
        context.startService(intent);
    }
}