package com.vipera.decore;
import com.vipera.de.utility.ProxyDetector;
import com.vipera.de.utility.Rooted;
import com.vipera.de.utility.Utility;
import com.vipera.de.utility.VPNDetector;

import org.apache.cordova.CallbackContext;
import org.apache.cordova.CordovaInterface;
import org.apache.cordova.CordovaPlugin;
import org.apache.cordova.CordovaWebView;
import org.apache.cordova.PluginResult;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.net.ProxySelector;
import java.net.URI;

import static com.vipera.de.utility.VPNDetector.getInstance;

public class DECoreSecurityPlugin extends CordovaPlugin{
    private static final String IS_PROXY_SET_ACTION = "isProxySet";
    private static final String IS_DEVICE_ROOTED_ACTION = "isDeviceRooted";
    private static final String IS_VPN_SET_ACTION = "isVPNSet";
    private static final String IS_CONSOLE_LOG_DISABLED = "isConsoleLogDisabled";

    private static final String PROTOCOL_TO_CHECK_TAG = "protocol";
    private static final String PROXY_CHECK_RESPONSE_TAG = "isProxyPresent";
    private static final String VPN_CHECK_RESPONSE_TAG = "isVpnPresent";
    private static final String DEVICE_ROOTED_RESPONSE_TAG = "isDeviceRooted";
    private static final String ERROR_CODE_TAG = "errorCode";
    private static final String ERROR_DESCRIPTION_TAG = "errorDescription";
    public static final String PROTOCOL_PARSE_EXCEPTION = "ProtocolParseException";
    public static final String PROTOCOL_PARSE_EXCEPTION_DESCR = "Protocol parse fail";

    private enum Protocol{
        HTTP("http://localhost/"),
        HTTPS("https://localhost/"),
        FTP("ftp://localhost/");
        private String uriStr;
        Protocol(String uriStr){
            this.uriStr=uriStr;
        }

        public URI getUri() {
            return URI.create(this.uriStr);
        }
        public String getUriString(){
            return uriStr;
        }

        public static Protocol getProtocolByTag(String tag){
            if("HTTP".equalsIgnoreCase(tag)){
                return HTTP;
            }else if("HTTPS".equalsIgnoreCase(tag)){
                return HTTPS;
            }else if("FTP".equalsIgnoreCase(tag)){
                return FTP;
            }
            return null;
        }
    }

    @Override
    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
        super.initialize(cordova, webView);
        ProxyDetector.initialize(cordova.getActivity().getApplicationContext());
        VPNDetector.initialize(cordova.getActivity().getApplicationContext());
    }


    @Override
    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
        if(IS_VPN_SET_ACTION.equals(action)){
            execIsVPNSet(callbackContext);
            return true;
        }else if(IS_PROXY_SET_ACTION.equals(action)){
            JSONObject checkInfo=args.optJSONObject(0);
            execIsProxySet(checkInfo,callbackContext);
            return true;
        }else if(IS_DEVICE_ROOTED_ACTION.equals(action)){
            execIsDeviceRooted(callbackContext);
            return true;
        } else if( IS_CONSOLE_LOG_DISABLED.equals(action)){
            execIsConsoleLogDisabled(callbackContext);
            return true;
        }
        return false;
    }

    private void execIsVPNSet (final CallbackContext callbackContext){
        cordova.getThreadPool().execute(new Runnable() {
            @Override
            public void run() {
                boolean present=VPNDetector.getInstance().isVPNPresent();
                JSONObject response=createCheckResponse(VPN_CHECK_RESPONSE_TAG,present);
                if(response==null){
                    sendGenericError(callbackContext);
                    return;
                }
                callbackContext.success(response);
            }
        });

    }

    private void sendGenericError(CallbackContext callbackContext) {

    }

    private void execIsProxySet(final JSONObject params, final CallbackContext callbackContext){
        cordova.getThreadPool().execute(new Runnable() {
            @Override
            public void run() {
                String tagToCheck = params!=null ? params.optString(PROTOCOL_TO_CHECK_TAG,null) : null;
                if(tagToCheck == null){
                    checkProxyWithAllProtocols(callbackContext);
                    return;
                }
                Protocol protocolToCheck=Protocol.getProtocolByTag(tagToCheck);
                if(protocolToCheck==null){
                    sendProtocolParseFailure(tagToCheck, callbackContext);
                    return;
                }
                checkProxyWithProtocol(protocolToCheck,callbackContext);
            }
        });
    }

    private void checkProxyWithProtocol(Protocol protocolToCheck, CallbackContext callbackContext) {
        boolean checkResult=isProxyEnable(protocolToCheck);
        JSONObject response=createCheckResponse(PROXY_CHECK_RESPONSE_TAG,checkResult);
        if(response==null){
            sendGenericError(callbackContext);
            return;
        }
        callbackContext.success(response);
    }

    private boolean isProxyEnable(Protocol protocolToCheck){
       return ProxyDetector.getInstance().isProxySet(protocolToCheck.getUriString());
    }


    private JSONObject createCheckResponse(String responseTag, boolean checkResult) {
        JSONObject responseObject=new JSONObject();
        try{
            responseObject.put(responseTag,checkResult);
            return responseObject;
        }catch (Exception ex){
            Utility.logE("createCheckResponse exception:",ex);
        }
        return null;
    }

    private void sendProtocolParseFailure(String tagToCheck, CallbackContext callbackContext) {
        JSONObject error=new JSONObject();
        try {
            error.put(ERROR_CODE_TAG, PROTOCOL_PARSE_EXCEPTION);
            error.put(ERROR_DESCRIPTION_TAG, PROTOCOL_PARSE_EXCEPTION_DESCR);
            callbackContext.error(error);
        }catch (Exception ex){
            Utility.logE("sendProtocolParseFailure exception",ex);
            callbackContext.error("GENERIC_ERROR");
        }
    }

    private void checkProxyWithAllProtocols(CallbackContext callbackContext) {
        Protocol[] allProtocols=Protocol.values();
        boolean checkResult=false;
        for(Protocol p:allProtocols){
            boolean checkP=isProxyEnable(p);
            checkResult = checkResult || checkP;
        }
        JSONObject result=createCheckResponse(PROXY_CHECK_RESPONSE_TAG,checkResult);
        if(result==null){
            sendGenericError(callbackContext);
            return;
        }
        callbackContext.success(result);
    }

    private void execIsDeviceRooted(final CallbackContext callbackContext){
        cordova.getThreadPool().execute(new Runnable() {
            @Override
            public void run() {
                boolean checkResult=Rooted.isDeviceRooted();
                JSONObject result=createCheckResponse(DEVICE_ROOTED_RESPONSE_TAG,checkResult);
                if(result == null){
                    sendGenericError(callbackContext);
                    return;
                }
                callbackContext.success(result);
            }
        });
    }

    private void execIsConsoleLogDisabled(final CallbackContext callbackContext){
        cordova.getThreadPool().execute(new Runnable() {
            @Override
            public void run() {
                boolean isDisabled = DECoreSecurityPlugin.this.preferences.getBoolean("de.security.disableConsoleLog", false);
                callbackContext.sendPluginResult(new PluginResult(PluginResult.Status.OK, isDisabled));
            }
        });
    }

}