package com.reactnativezoom.videosdk;

import android.content.Context;
import android.content.Intent;
import android.media.projection.MediaProjectionManager;
import android.os.Build;
import android.util.Log;
import android.app.Activity;

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 com.reactnativezoom.videosdk.convert.RNZoomVideoSDKErrors;

import us.zoom.sdk.ZoomVideoSDK;
import us.zoom.sdk.ZoomVideoSDKShareHelper;
public class RNZoomVideoSdkShareHelperModule extends ReactContextBaseJavaModule {

  private final ReactApplicationContext reactContext;

  public final static int REQUEST_SHARE_SCREEN_PERMISSION = 1001;

  public final static int REQUEST_STOP_SHARE = 1002;

  RNZoomVideoSdkShareHelperModule(ReactApplicationContext reactContext) {
    super(reactContext);
    this.reactContext = reactContext;
  }

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

  private ZoomVideoSDKShareHelper getShareHelper() {
    ZoomVideoSDKShareHelper shareHelper = null;
    try {
      shareHelper = ZoomVideoSDK.getInstance().getShareHelper();
      if (shareHelper == null) {
        throw new Exception("No Share Found");
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return shareHelper;
  }

  @ReactMethod
  public void shareScreen() throws Exception {
    if (Build.VERSION.SDK_INT < 21) {
      return;
    }
    if (ZoomVideoSDK.getInstance().getShareHelper().isSharingOut()) {
      return;
    }
    MediaProjectionManager mgr = (MediaProjectionManager) reactContext.getSystemService(Context.MEDIA_PROJECTION_SERVICE);
    if (mgr != null) {
      Intent intent = mgr.createScreenCaptureIntent();
      try {
        Activity activity = getReactApplicationContext().getCurrentActivity();
        activity.startActivityForResult(intent, REQUEST_SHARE_SCREEN_PERMISSION);
      } catch (Exception e) {
        Log.e("ZoomVideoSdkDebug", "askScreenSharePermission failed");
      }
    }
  }

  @ReactMethod
  public void shareView() {
    // TODO
  }

  @ReactMethod
  public void lockShare(boolean lock, Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(RNZoomVideoSDKErrors.valueOf(getShareHelper().lockShare(lock)));
      }
    });
  }

  @ReactMethod
  public void stopShare(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(RNZoomVideoSDKErrors.valueOf(getShareHelper().stopShare()));
      }
    });
  }

  @ReactMethod
  public void isOtherSharing(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(getShareHelper().isOtherSharing());
      }
    });
  }

  @ReactMethod
  public void isScreenSharingOut(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(getShareHelper().isScreenSharingOut());
      }
    });
  }

  @ReactMethod
  public void isShareLocked(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(getShareHelper().isShareLocked());
      }
    });
  }

  @ReactMethod
  public void isSharingOut(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(getShareHelper().isSharingOut());
      }
    });
  }

  @ReactMethod
  public void isAnnotationFeatureSupport(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(getShareHelper().isAnnotationFeatureSupport());
      }
    });
  }

  @ReactMethod
  public void disableViewerAnnotation(boolean disable, Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(getShareHelper().disableViewerAnnotation(disable));
      }
    });
  }

  @ReactMethod
  public void isViewerAnnotationDisabled(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(getShareHelper().isViewerAnnotationDisabled());
      }
    });
  }

  @ReactMethod
  public void destroyAnnotationHelper(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(getShareHelper().destroyAnnotationHelper(RNZoomViewManager.getInstance().annotationHelper));
      }
    });
  }

  @ReactMethod
  public void enableShareDeviceAudio(boolean enable, Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(RNZoomVideoSDKErrors.valueOf(getShareHelper().enableShareDeviceAudio(enable)));
      }
    });
  }

  @ReactMethod
  public void pauseShare(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(RNZoomVideoSDKErrors.valueOf(getShareHelper().pauseShare()));
      }
    });
  }

  @ReactMethod
  public void resumeShare(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(RNZoomVideoSDKErrors.valueOf(getShareHelper().resumeShare()));
      }
    });
  }

}