package im.actor.core.viewmodel;

import com.google.j2objc.annotations.Property;

import im.actor.core.events.AppVisibleChanged;
import im.actor.core.events.ConnectingStateChanged;
import im.actor.core.modules.ModuleContext;
import im.actor.core.viewmodel.generics.BooleanValueModel;
import im.actor.core.viewmodel.generics.IntValueModel;
import im.actor.runtime.eventbus.BusSubscriber;
import im.actor.runtime.eventbus.Event;

public class GlobalStateVM {

    @Property("nonatomic, readonly")
    private BooleanValueModel isAppVisible;
    @Property("nonatomic, readonly")
    private BooleanValueModel isConnecting;
    @Property("nonatomic, readonly")
    private BooleanValueModel isSyncing;
    @Property("nonatomic, readonly")
    private IntValueModel globalCounter;
    @Property("nonatomic, readonly")
    private IntValueModel globalTempCounter;

    public GlobalStateVM(ModuleContext context) {
        this.isAppVisible = new BooleanValueModel("app.visible", false);
        this.globalCounter = new IntValueModel("app.counter", null);
        this.globalTempCounter = new IntValueModel("app.temp_counter", 0);
        this.isConnecting = new BooleanValueModel("app.connecting", false);
        this.isSyncing = new BooleanValueModel("app.syncing", false);

        context.getEvents().subscribe(event -> {
            if (event instanceof AppVisibleChanged) {
                if (((AppVisibleChanged) event).isVisible()) {
                    isAppVisible.change(true);
                    globalTempCounter.change(0);
                } else {
                    isAppVisible.change(false);
                }
            }
        }, AppVisibleChanged.EVENT);

        context.getEvents().subscribe(event -> {
            isConnecting.change(((ConnectingStateChanged) event).isConnecting());
        }, ConnectingStateChanged.EVENT);
    }


    /**
     * Notify from Modules about global counters changed
     *
     * @param value current value of global counter
     */
    public synchronized void onGlobalCounterChanged(int value) {
        globalCounter.change(value);
        if (!isAppVisible.get()) {
            globalTempCounter.change(value);
        }
    }

    /**
     * Is syncing in progress
     *
     * @return View Model of Boolean
     */
    public BooleanValueModel getIsSyncing() {
        return isSyncing;
    }

    /**
     * Is Connecting in progress
     *
     * @return View Model of Boolean
     */
    public BooleanValueModel getIsConnecting() {
        return isConnecting;
    }


    /**
     * Gettting global unread counter
     *
     * @return View Model of Integer
     */
    public IntValueModel getGlobalCounter() {
        return globalCounter;
    }

    /**
     * Getting global unread counter that resets when app is opened
     *
     * @return View Model of Integer
     */
    public IntValueModel getGlobalTempCounter() {
        return globalTempCounter;
    }

    /**
     * Is App visible state
     *
     * @return View Model of Boolean
     */
    public BooleanValueModel getIsAppVisible() {
        return isAppVisible;
    }
}