package com.moonmiles.bridge.apm.service.user;

import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.bridge.ReadableMap;
import com.moonmiles.apmservices.model.APMAds;
import com.moonmiles.apmservices.model.APMBurns;
import com.moonmiles.apmservices.model.APMEarns;
import com.moonmiles.apmservices.model.APMUser;
import com.moonmiles.apmservices.model.APMUsers;
import com.moonmiles.apmservices.net.APMException;
import com.moonmiles.apmservices.sdk.user.APMServicesUser;
import com.moonmiles.apmservices.sdk.user.APMUserCheckTokenListener;
import com.moonmiles.apmservices.sdk.user.APMUserConnectListener;
import com.moonmiles.apmservices.sdk.user.APMUserContactListener;
import com.moonmiles.apmservices.sdk.user.APMUserCreateListener;
import com.moonmiles.apmservices.sdk.user.APMUserDeleteListener;
import com.moonmiles.apmservices.sdk.user.APMUserEvaluateListener;
import com.moonmiles.apmservices.sdk.user.APMUserFBConnectListener;
import com.moonmiles.apmservices.sdk.user.APMUserGetSettingsListener;
import com.moonmiles.apmservices.sdk.user.APMUserHistoryBurnsListener;
import com.moonmiles.apmservices.sdk.user.APMUserHistoryEarnsListener;
import com.moonmiles.apmservices.sdk.user.APMUserHistoryListener;
import com.moonmiles.apmservices.sdk.user.APMUserListListener;
import com.moonmiles.apmservices.sdk.user.APMUserLogoutListener;
import com.moonmiles.apmservices.sdk.user.APMUserRefreshListener;
import com.moonmiles.apmservices.sdk.user.APMUserResetPasswordListener;
import com.moonmiles.apmservices.sdk.user.APMUserSaveListener;
import com.moonmiles.apmservices.sdk.user.APMUserSavePasswordListener;
import com.moonmiles.apmservices.sdk.user.APMUserSavePushTokenListener;
import com.moonmiles.apmservices.sdk.user.APMUserSaveSettingsListener;
import com.moonmiles.apmservices.sdk.user.APMUserUnsubscribeListener;
import com.moonmiles.bridge.apm.abs.APMReactContextBaseJavaModule;
import com.moonmiles.bridge.apm.utils.APMBridgeUtils;

import java.util.HashMap;
import java.util.Map;

public class APMServicesUserModule extends APMReactContextBaseJavaModule
{

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

    @ReactMethod
    public static void userConnect(String email, String password, ReadableMap segments, final Promise promise)
    {
        try
        {
            HashMap hashSegments = null;
            if(segments != null)
                hashSegments = segments.toHashMap();

            APMServicesUser.userConnect(email, password, hashSegments, new APMUserConnectListener()
            {
                @Override
                public void userConnectSuccess(APMUser user)
                {
                    APMBridgeUtils.resolvePromise(user, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

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

    @Override
    public Map<String, Object> getConstants()
    {
        final Map<String, Object> constants = new HashMap<>();
        return constants;
    }

    @ReactMethod
    public static void userClientConnectWithJSON(ReadableMap user, final Promise promise)
    {
        try
        {
            APMServicesUser.userClientConnect(user.toHashMap(), new APMUserConnectListener() {
                @Override
                public void userConnectSuccess(APMUser user)
                {
                    APMBridgeUtils.resolvePromise(user, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userClientConnect(String firstname, String lastname, String email, String facebookId, String partnerClientId, String oldClientId, ReadableMap segments, Integer optIn, final Promise promise)
    {
        try
        {
            HashMap hashSegments = null;
            if(segments != null)
                hashSegments = segments.toHashMap();

            APMServicesUser.userClientConnect(firstname, lastname, email, facebookId, partnerClientId, oldClientId, hashSegments, optIn, new APMUserConnectListener()
            {
                @Override
                public void userConnectSuccess(APMUser user)
                {
                    APMBridgeUtils.resolvePromise(user, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userLogout(final Promise promise)
    {
        try
        {
            APMServicesUser.userLogout(new APMUserLogoutListener()
            {
                @Override
                public void userLogoutSuccess()
                {
                    APMBridgeUtils.resolvePromise(null, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userCreate(String firstname, String lastname, String email, String password, String facebookId, ReadableMap segments, final Promise promise)
    {
        try
        {
            HashMap hashSegments = null;
            if(segments != null)
                hashSegments = segments.toHashMap();

            APMServicesUser.userCreate(firstname, lastname, email, password, facebookId, hashSegments, new APMUserCreateListener()
            {
                @Override
                public void userCreateSuccess(APMUser user)
                {
                    APMBridgeUtils.resolvePromise(user, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userSave(String firstname, String lastname, String mobile, String gender, String birthday, String city, String facebookId, ReadableMap segments, final Promise promise)
    {
        try
        {
            HashMap hashSegments = null;
            if(segments != null)
                hashSegments = segments.toHashMap();

            APMServicesUser.userSave(firstname, lastname, mobile, gender, birthday, city, facebookId, hashSegments, new APMUserSaveListener()
            {
                @Override
                public void userSaveSuccess(APMUser user)
                {
                    APMBridgeUtils.resolvePromise(user, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userClientSaveWithJSON(ReadableMap user, final Promise promise)
    {
        try
        {
            APMServicesUser.userClientSave(user.toHashMap(), new APMUserSaveListener()
            {
                @Override
                public void userSaveSuccess(APMUser user)
                {
                    APMBridgeUtils.resolvePromise(user, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userClientSave(String email, String firstname, String lastname, String mobile, String gender, String birthday, String city, String facebookId, String partnerClientId, ReadableMap segments, final Promise promise)
    {
        try
        {
            HashMap hashSegments = null;
            if(segments != null)
                hashSegments = segments.toHashMap();

            APMServicesUser.userClientSave(email, firstname, lastname, mobile, gender, birthday, city, facebookId, partnerClientId, hashSegments, new APMUserSaveListener()
            {
                @Override
                public void userSaveSuccess(APMUser user)
                {
                    APMBridgeUtils.resolvePromise(user, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userSavePassword(String oldPassword, String newPassword, String confirmPassword, final Promise promise)
    {
        try
        {
            APMServicesUser.userSavePassword(oldPassword, newPassword, confirmPassword, new APMUserSavePasswordListener()
            {
                @Override
                public void userSavePasswordSuccess(APMUser user)
                {
                    APMBridgeUtils.resolvePromise(user, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userRefresh(final Promise promise)
    {
        try
        {
            APMServicesUser.userRefresh(new APMUserRefreshListener()
            {
                @Override
                public void userRefreshSuccess(APMUser user)
                {
                    APMBridgeUtils.resolvePromise(user, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userResetPassword(String email, final Promise promise)
    {
        try
        {
            APMServicesUser.userResetPassword(email, new APMUserResetPasswordListener()
            {
                @Override
                public void userResetPasswordSuccess(String message)
                {
                    APMBridgeUtils.resolvePromise(message, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userHistory(final Promise promise)
    {
        try
        {
            APMServicesUser.userHistory(new APMUserHistoryListener()
            {
                @Override
                public void userHistorySuccess(APMUser user, APMEarns earns, APMBurns burns, APMAds ads)
                {
                    HashMap map = new HashMap();
                    map.put("user", user);
                    map.put("earns", earns);
                    map.put("burns", burns);
                    map.put("ads", ads);
                    APMBridgeUtils.resolvePromise(map, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userHistoryBurns(final Promise promise)
    {
        try
        {
            APMServicesUser.userHistoryBurns(new APMUserHistoryBurnsListener()
            {
                @Override
                public void userHistoryBurnsSuccess(APMBurns burns)
                {
                    APMBridgeUtils.resolvePromise(burns, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userHistoryEarns(final Promise promise)
    {
        try
        {
            APMServicesUser.userHistoryEarns(new APMUserHistoryEarnsListener()
            {
                @Override
                public void userHistoryEarnsSuccess(APMEarns earns)
                {
                    APMBridgeUtils.resolvePromise(earns, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userUnsubscribe(String comment, final Promise promise)
    {
        try
        {
            APMServicesUser.userUnsubscribe(comment, new APMUserUnsubscribeListener()
            {
                @Override
                public void userUnsubscribeSuccess()
                {
                    APMBridgeUtils.resolvePromise(null, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userContact(String comment, final Promise promise)
    {
        try
        {
            APMServicesUser.userContact(comment, new APMUserContactListener()
            {
                @Override
                public void userContactSuccess(String message)
                {
                    APMBridgeUtils.resolvePromise(message, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userEvaluate(String note, String comment, final Promise promise)
    {
        try
        {
            APMServicesUser.userEvaluate(note, comment, new APMUserEvaluateListener()
            {
                @Override
                public void userEvaluateSuccess(String message)
                {
                    APMBridgeUtils.resolvePromise(message, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userGetSettings(final Promise promise)
    {
        try
        {
            APMServicesUser.userGetSettings(new APMUserGetSettingsListener()
            {
                @Override
                public void userGetSettingsSuccess(boolean push, boolean mail, boolean sms)
                {
                    HashMap map = new HashMap();
                    map.put("push", push);
                    map.put("mail", mail);
                    map.put("sms", sms);
                    APMBridgeUtils.resolvePromise(map, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userSaveSettings(boolean push, boolean mail, boolean sms, String phone, final Promise promise)
    {
        try
        {
            APMServicesUser.userSaveSettings(push, mail, sms, phone, new APMUserSaveSettingsListener()
            {
                @Override
                public void userSaveSettingsSuccess()
                {
                    APMBridgeUtils.resolvePromise(null, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userCheckToken(final Promise promise)
    {
        try
        {
            APMServicesUser.userCheckToken(new APMUserCheckTokenListener()
            {
                @Override
                public void userCheckTokenSuccess(APMUser user)
                {
                    APMBridgeUtils.resolvePromise(user, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userFBConnect(String email, String facebookId, String partnerClientId, ReadableMap segments, final Promise promise)
    {
        try
        {
            HashMap hashSegments = null;
            if(segments != null)
                hashSegments = segments.toHashMap();

            APMServicesUser.userFBConnect(email, facebookId, partnerClientId, hashSegments, new APMUserFBConnectListener()
            {
                @Override
                public void userFBConnectSuccess(APMUser user)
                {
                    APMBridgeUtils.resolvePromise(user, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userSavePushToken(String pushToken, final Promise promise)
    {
        try
        {
            APMServicesUser.userSavePushToken(pushToken, new APMUserSavePushTokenListener()
            {
                @Override
                public void userSavePushTokenSuccess()
                {
                    APMBridgeUtils.resolvePromise(null, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userDelete(final Promise promise)
    {
        try
        {
            APMServicesUser.userDelete(new APMUserDeleteListener()
            {
                @Override
                public void userDeleteSuccess()
                {
                    APMBridgeUtils.resolvePromise(null, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }

    @ReactMethod
    public void userList(ReadableArray partnerClientIds, final Promise promise)
    {
        try
        {
            APMServicesUser.userList(partnerClientIds.toArrayList(), new APMUserListListener()
            {
                @Override
                public void userListSuccess(APMUsers users)
                {
                    APMBridgeUtils.resolvePromise(users, promise);
                }

                @Override
                public void failure(APMException e)
                {
                    APMBridgeUtils.rejectPromise(e, promise);
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
            APMBridgeUtils.rejectPromise(e, promise);
        }
    }
}