package com.reactnativezoom.videosdk;

import androidx.annotation.NonNull;

import android.graphics.Color;

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 com.reactnativezoom.videosdk.convert.RNZoomVideoSdkAnnotationClearType;
import com.reactnativezoom.videosdk.convert.RNZoomVideoSdkAnnotationToolType;

import us.zoom.sdk.ZoomVideoSDKAnnotationHelper;

public class RNZoomVideoSdkAnnotationHelperModule extends ReactContextBaseJavaModule {

  private final ReactApplicationContext reactContext;
  private ZoomVideoSDKAnnotationHelper annotationHelper;

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

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

  private ZoomVideoSDKAnnotationHelper getAnnotationHelper() {
    try {
      annotationHelper = RNZoomViewManager.getInstance().annotationHelper;
      if (annotationHelper == null) {
        throw new Exception("No Annotation Helper Found");
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return annotationHelper;
  }

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

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

  @ReactMethod
  public void setToolColor(String toolColor, Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(RNZoomVideoSDKErrors.valueOf(getAnnotationHelper().setToolColor(Color.parseColor(toolColor))));
      }
    });
  }

  @ReactMethod
  public void getToolColor(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        String hexColor = String.format("#%06X", (0xFFFFFF & getAnnotationHelper().getToolColor()));
        promise.resolve(hexColor);
      }
    });
  }

  @ReactMethod
  public void setToolType(String toolType, Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(RNZoomVideoSDKErrors.valueOf(getAnnotationHelper().setToolType(RNZoomVideoSdkAnnotationToolType.valueOf(toolType))));
      }
    });
  }

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

  @ReactMethod
  public void setToolWidth(double width, Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(RNZoomVideoSDKErrors.valueOf(getAnnotationHelper().setToolWidth((long) width)));
      }
    });
  }

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

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

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

  @ReactMethod
  public void clear(String clearType, Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    reactContext.getCurrentActivity().runOnUiThread(new Runnable() {
      @Override
      public void run() {
        promise.resolve(RNZoomVideoSDKErrors.valueOf(getAnnotationHelper().clear(RNZoomVideoSdkAnnotationClearType.valueOf(clearType))));
      }
    });
  }

  @ReactMethod
  public void canDoAnnotation(Promise promise) {
    if (Utils.checkRNActivity(reactContext, promise)) {
      return;
    }
    promise.resolve(getAnnotationHelper().canDoAnnotation());
  }
}