package io.textile.rnmobile;

import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

import io.textile.pb.View;
import io.textile.textile.Textile;

public class InvitesBridge extends ReactContextBaseJavaModule {

    private Executor executor = Executors.newSingleThreadExecutor();

    public InvitesBridge(ReactApplicationContext reactContext) {
        super(reactContext);
    }

    @Override
    public String getName() {
        return "InvitesBridge";
    }

    @ReactMethod
    public void add(final String threadId, final String address, final Promise promise) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Textile.instance().invites.add(threadId, address);
                    promise.resolve(null);
                }
                catch (final Exception e) {
                    promise.reject("add", e);
                }
            }
        });
    }

    @ReactMethod
    public void addExternal(final String threadId, final Promise promise) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    final View.ExternalInvite invite = Textile.instance().invites.addExternal(threadId);
                    promise.resolve(Util.encode(invite.toByteArray()));
                }
                catch (final Exception e) {
                    promise.reject("addExternal", e);
                }
            }
        });
    }

    @ReactMethod
    public void list(final Promise promise) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    final View.InviteViewList list = Textile.instance().invites.list();
                    promise.resolve(Util.encode(list.toByteArray()));
                } catch (final Exception e) {
                    promise.reject("list", e);
                }
            }
        });
    }

    @ReactMethod
    public void accept(final String inviteId, final Promise promise) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    promise.resolve(Textile.instance().invites.accept(inviteId));
                } catch (final Exception e) {
                    promise.reject("accept", e);
                }
            }
        });
    }

    @ReactMethod
    public void acceptExternal(final String inviteId, final String key, final Promise promise) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    promise.resolve(Textile.instance().invites.acceptExternal(inviteId, key));
                }
                catch (final Exception e) {
                    promise.reject("acceptExternal", e);
                }
            }
        });
    }

    @ReactMethod
    public void ignore(final String inviteId, final Promise promise) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Textile.instance().invites.ignore(inviteId);
                    promise.resolve(null);
                } catch (Exception e) {
                    promise.reject("ignore", e);
                }
            }
        });
    }
}