package com.reactnativevdotok;


import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.media.projection.MediaProjection;
import android.media.projection.MediaProjectionManager;
import android.util.DisplayMetrics;
import android.util.Log;

import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.BaseActivityEventListener;
import com.facebook.react.bridge.Callback;
import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.UiThreadUtil;
import com.facebook.react.bridge.WritableArray;
import com.facebook.react.bridge.WritableMap;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import org.webrtc.*;

/**
 * The implementation of {@code getUserMedia} extracted into a separate file in
 * order to reduce complexity and to (somewhat) separate concerns.
 */
class GetUserMediaImpl {
  /**
   * The {@link Log} tag with which {@code GetUserMediaImpl} is to log.
   */
  private static final String TAG = VdotokModule.TAG;

  private static int PERMISSION_REQUEST_CODE = (int) (Math.random() * Short.MAX_VALUE);

  private final CameraEnumerator cameraEnumerator;
  private final ReactApplicationContext reactContext;
  private Intent projectionIntent;
  private int rCode;
  private MediaProjectionManager manager=null;
  public MediaProjection currentProjection=null;
  private ReadableMap constr;
  public ScreenCaptureController screenCaptureInstance;
  public AudioSource audioSourcee;
  public AudioTrack audioTrackk;
  public VideoSource screenSourcee;
  public VideoTrack screenTrackk;
  public Activity activ;

  /**
   * The application/library-specific private members of local
   * {@link MediaStreamTrack}s created by {@code GetUserMediaImpl} mapped by
   * track ID.
   */
  private final Map<String, TrackPrivate> tracks = new HashMap<>();

  private final VdotokModule vdotokModule;

  private Promise displayMediaPromise;
  private Intent mediaProjectionPermissionResultData;

  GetUserMediaImpl(VdotokModule vdotokModule, ReactApplicationContext reactContext) {
    this.vdotokModule = vdotokModule;
    this.reactContext = reactContext;

    boolean camera2supported = false;

    try {
      camera2supported = Camera2Enumerator.isSupported(reactContext);
    } catch (Throwable tr) {
      // Some devices will crash here with: Fatal Exception: java.lang.AssertionError: Supported FPS ranges cannot be null.
      // Make sure we don't.
      Log.w(TAG, "Error checking for Camera2 API support.", tr);
    }

    if (camera2supported) {
      Log.d(TAG, "Creating video capturer using Camera2 API.");
      cameraEnumerator = new Camera2Enumerator(reactContext);
    } else {
      Log.d(TAG, "Creating video capturer using Camera1 API.");
      cameraEnumerator = new Camera1Enumerator(false);
    }

    reactContext.addActivityEventListener(new BaseActivityEventListener() {
      @Override
      public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
        super.onActivityResult(activity, requestCode, resultCode, data);

        rCode = resultCode;

        if (requestCode == PERMISSION_REQUEST_CODE) {

          if (resultCode != Activity.RESULT_OK) {
            displayMediaPromise.reject("DOMException", "NotAllowedError");
            displayMediaPromise = null;
            return;
          }
          Log.d("ham->", "onActivityResult end: "+manager.toString());
          Log.d("ham->", "onActivityResult: resultCode"+resultCode);
          Log.d("ham->", "onActivityResult: data(intent)"+data.toString());
          Log.d("ham->", "onActivityResult: activity"+activity.toString());
          Log.d("ham->", "onActivityResult:requestCode "+requestCode);
          Log.d("ham->", "onActivityResult:PERMISSION_REQUEST_CODE "+PERMISSION_REQUEST_CODE);
          MediaProjection projection= manager.getMediaProjection(
            resultCode, data);
//          projectionIntent = data;
          currentProjection=projection;
          mediaProjectionPermissionResultData = data;
          activ=activity;
//          MediaProjection projection= null;
//          Log.d("ham projection->", "projection creation end:  "+projection.toString());
          try {
            vdotokModule.createPeerConnectionFactoryForSS(currentProjection);
          } catch (Throwable e) {
            e.printStackTrace();
          }
          Log.d("ham->", "createPeerConnectionFactoryForSS end");


          Log.d("jam", "onActivityResult: "+activ);
//          createScreenStream();
        }
      }
    });
  }

  private AudioTrack createAudioTrack(ReadableMap constraints) {
    Log.d("ham->", "createAudioTrack: "+constraints.toString());
    ReadableMap audioConstraintsMap = constraints.getMap("audio");
    Log.d("ham->", "getUserMedia(audio): " + audioConstraintsMap);

    Log.d(TAG, "getUserMedia(audio): " + audioConstraintsMap);

    String id = UUID.randomUUID().toString();
    PeerConnectionFactory pcFactory = vdotokModule.mFactory;
    MediaConstraints peerConstraints = vdotokModule.constraintsForOptions(audioConstraintsMap);

    //PeerConnectionFactory.createAudioSource will throw an error when mandatory constraints contain nulls.
    //so, let's check for nulls
    checkMandatoryConstraints(peerConstraints);
    AudioSource audioSource = pcFactory.createAudioSource(peerConstraints);
    AudioTrack track = pcFactory.createAudioTrack(id, audioSource);
    audioSourcee=audioSource;
    audioTrackk=track;
    // surfaceTextureHelper is initialized for videoTrack only, so its null here.
    tracks.put(
      id,
      new TrackPrivate(track, audioSource, /* videoCapturer */ null, /* surfaceTextureHelper */ null));

    return track;
  }

  private void checkMandatoryConstraints(MediaConstraints peerConstraints) {
    ArrayList<MediaConstraints.KeyValuePair> valid = new ArrayList<>(peerConstraints.mandatory.size());

    for (MediaConstraints.KeyValuePair constraint : peerConstraints.mandatory) {
      if (constraint.getValue() != null) {
        valid.add(constraint);
      } else {
        Log.d(TAG, String.format("constraint %s is null, ignoring it",
          constraint.getKey()));
      }
    }

    peerConstraints.mandatory.clear();
    peerConstraints.mandatory.addAll(valid);
  }

  ReadableArray enumerateDevices() {
    WritableArray array = Arguments.createArray();
    String[] devices = cameraEnumerator.getDeviceNames();

    for (int i = 0; i < devices.length; ++i) {
      String deviceName = devices[i];
      boolean isFrontFacing;
      try {
        // This can throw an exception when using the Camera 1 API.
        isFrontFacing = cameraEnumerator.isFrontFacing(deviceName);
      } catch (Exception e) {
        Log.e(TAG, "Failed to check the facing mode of camera");
        continue;
      }
      WritableMap params = Arguments.createMap();
      params.putString("facing", isFrontFacing ? "front" : "environment");
      params.putString("deviceId", "" + i);
      params.putString("groupId", "");
      params.putString("label", deviceName);
      params.putString("kind", "videoinput");
      array.pushMap(params);
    }

    WritableMap audio = Arguments.createMap();
    audio.putString("deviceId", "audio-1");
    audio.putString("groupId", "");
    audio.putString("label", "Audio");
    audio.putString("kind", "audioinput");
    array.pushMap(audio);

    return array;
  }

  MediaStreamTrack getTrack(String id) {
    TrackPrivate private_ = tracks.get(id);

    return private_ == null ? null : private_.track;
  }

  /**
   * Implements {@code getUserMedia}. Note that at this point constraints have
   * been normalized and permissions have been granted. The constraints only
   * contain keys for which permissions have already been granted, that is,
   * if audio permission was not granted, there will be no "audio" key in
   * the constraints map.
   */
  void getUserMedia(
    final ReadableMap constraints,
    final Callback successCallback,
    final Callback errorCallback) {

    AudioTrack audioTrack = null;
    VideoTrack videoTrack = null;

    if (constraints.hasKey("audio")) {
      audioTrack = createAudioTrack(constraints);
    }

    if (constraints.hasKey("video")) {
      ReadableMap videoConstraintsMap = constraints.getMap("video");

      Log.d(TAG, "getUserMedia(video): " + videoConstraintsMap);

      CameraCaptureController cameraCaptureController = new CameraCaptureController(
        cameraEnumerator,
        videoConstraintsMap);

      videoTrack = createVideoTrack(cameraCaptureController);
    }

    if (audioTrack == null && videoTrack == null) {
      // Fail with DOMException with name AbortError as per:
      // https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-getusermedia
      errorCallback.invoke("DOMException", "AbortError");
      return;
    }

    createStream(new MediaStreamTrack[]{audioTrack, videoTrack}, (streamId, tracksInfo) -> {
      WritableArray tracksInfoWritableArray = Arguments.createArray();

      for (WritableMap trackInfo : tracksInfo) {
        tracksInfoWritableArray.pushMap(trackInfo);
      }

      successCallback.invoke(streamId, tracksInfoWritableArray);
    });
  }

  void mediaStreamTrackSetEnabled(String trackId, final boolean enabled) {
    TrackPrivate track = tracks.get(trackId);
    if (track != null && track.videoCaptureController != null) {
      if (enabled) {
        track.videoCaptureController.startCapture();
      } else {
        track.videoCaptureController.stopCapture();
      }
    }
  }

  void disposeTrack(String id) {
    TrackPrivate track = tracks.remove(id);
    if (track != null) {
      track.dispose();
    }
  }

  void switchCamera(String trackId) {
    TrackPrivate track = tracks.get(trackId);
    if (track != null && track.videoCaptureController instanceof CameraCaptureController) {
      CameraCaptureController cameraCaptureController = (CameraCaptureController) track.videoCaptureController;
      cameraCaptureController.switchCamera();
    }
  }

  void getDisplayMedia(ReadableMap constraints,Promise promise) {
//    PERMISSION_REQUEST_CODE = (int) (Math.random() * Short.MAX_VALUE);
    constr=constraints;
    if (this.displayMediaPromise != null) {
      promise.reject(new RuntimeException("Another operation is pending."));
      return;
    }
    Activity currentActivity=null;
     currentActivity = this.reactContext.getCurrentActivity();
    Log.d("hamz->", "getDisplayMedia: "+currentActivity.toString());
    if (currentActivity == null) {
      promise.reject(new RuntimeException("No current Activity."));
      return;
    }

    this.displayMediaPromise = promise;

    MediaProjectionManager mediaProjectionManager =
      (MediaProjectionManager) currentActivity.getApplication().getSystemService(
        Context.MEDIA_PROJECTION_SERVICE);
        manager=null;
        manager=mediaProjectionManager;
        if (manager != null) {
          Activity finalCurrentActivity = currentActivity;
          UiThreadUtil.runOnUiThread(new Runnable() {
        @Override
        public void run() {
          Log.d("hamz->", "run: PERMISSION_REQUEST_CODE"+PERMISSION_REQUEST_CODE);
          finalCurrentActivity.startActivityForResult(
            manager.createScreenCaptureIntent(), PERMISSION_REQUEST_CODE);
        }
      });

    } else {
      promise.reject(new RuntimeException("MediaProjectionManager is null."));
    }
  }

  public void createScreenStream() {
    Log.d("hamz->", "createScreenStream: i am in this function");

//    if (track == null) {
//      displayMediaPromise.reject(new RuntimeException("ScreenTrack is null."));
//    } else {
      AudioTrack audioTrack = null;
      audioTrack = createAudioTrack(constr);
//      createStream(new MediaStreamTrack[]{audioTrack, videoTrack}, (streamId, tracksInfo) -> {
//        WritableArray tracksInfoWritableArray = Arguments.createArray();
//
//        for (WritableMap trackInfo : tracksInfo) {
//          tracksInfoWritableArray.pushMap(trackInfo);
//        }
//
//        successCallback.invoke(streamId, tracksInfoWritableArray);
//      });
    Log.d("jam", "createVideoTrack: 1 "+activ);

    VideoTrack track = createScreenTrack();

      createStream(new MediaStreamTrack[]{audioTrack, track}, (streamId, tracksInfo) -> {
        WritableMap data = Arguments.createMap();
        WritableArray tracksInfoWritableArray = Arguments.createArray();
        for (WritableMap trackInfo : tracksInfo) {
          tracksInfoWritableArray.pushMap(trackInfo);
        }
        data.putString("streamId", streamId);
        data.putArray("tracks",tracksInfoWritableArray);
        displayMediaPromise.resolve(data);
//        successCallback.invoke(streamId, tracksInfoWritableArray);
      });


      //        WritableArray tracksInfoWritableArray = Arguments.createArray();
//
//        for (WritableMap trackInfo : tracksInfo) {
//          tracksInfoWritableArray.pushMap(trackInfo);
//        }
//      createStream(new MediaStreamTrack[]{audioTrack,track}, (streamId, tracksInfo) -> {
////        WritableArray tracksInfoWritableArray = Arguments.createArray();
//        WritableMap data = Arguments.createMap();
//
//        data.putString("streamId", streamId);
//        Log.d("size", "createScreenStream: "+tracksInfo.toString());
//        if (tracksInfo.size() == 0) {
//          displayMediaPromise.reject(new RuntimeException("No ScreenTrackInfo found."));
//        } else if(tracksInfo.size() > 1) {
//          data.putMap("audiotrack", tracksInfo.get(0));
//          data.putMap("videotrack", tracksInfo.get(1));
//
//          displayMediaPromise.resolve(data);
//        }
//      });
//    }

    // Cleanup
    mediaProjectionPermissionResultData = null;
    displayMediaPromise = null;
  }

  private void createStream(MediaStreamTrack[] tracks, BiConsumer<String, ArrayList<WritableMap>> successCallback) {
    String streamId = UUID.randomUUID().toString();
    MediaStream mediaStream = vdotokModule.mFactory.createLocalMediaStream(streamId);

    ArrayList<WritableMap> tracksInfo = new ArrayList<>();

    for (MediaStreamTrack track : tracks) {
      if (track == null) {
        continue;
      }

      if (track instanceof AudioTrack) {
        mediaStream.addTrack((AudioTrack) track);
      } else {
        mediaStream.addTrack((VideoTrack) track);
      }

      WritableMap trackInfo = Arguments.createMap();
      String trackId = track.id();

      trackInfo.putBoolean("enabled", track.enabled());
      trackInfo.putString("id", trackId);
      trackInfo.putString("kind", track.kind());
      trackInfo.putString("label", trackId);
      trackInfo.putString("readyState", track.state().toString());
      trackInfo.putBoolean("remote", false);

      if (track instanceof VideoTrack) {
        TrackPrivate tp = this.tracks.get(trackId);
        AbstractVideoCaptureController vcc = tp.videoCaptureController;
        WritableMap settings = Arguments.createMap();
        settings.putInt("height", vcc.getHeight());
        settings.putInt("width", vcc.getWidth());
        settings.putInt("frameRate", vcc.getFrameRate());
        trackInfo.putMap("settings", settings);
      }

      tracksInfo.add(trackInfo);
    }

    Log.d(TAG, "MediaStream id: " + streamId);
    vdotokModule.localStreams.put(streamId, mediaStream);

    successCallback.accept(streamId, tracksInfo);
  }

  private VideoTrack createScreenTrack() {
    DisplayMetrics displayMetrics = DisplayUtils.getDisplayMetrics(activ);

    int width = displayMetrics.widthPixels;
    int height = displayMetrics.heightPixels;
    ScreenCaptureController screenCaptureController
      = new ScreenCaptureController(activ, width, height, mediaProjectionPermissionResultData);

    screenCaptureInstance=screenCaptureController;
    return createVideoTrack(screenCaptureController);
  }
  public void stopCapture(){
    if(screenCaptureInstance !=null){
      Log.d("ham->", "stopCapture: "+screenCaptureInstance.toString());
      if(audioTrackk!=null){
        Log.d("hamz->", " disposing audioTrackk"+audioTrackk.toString());
        audioTrackk.dispose();
      }
      if(audioSourcee!=null){
        Log.d("hamz->", " disposing audioSourcee"+audioSourcee.toString());
        audioSourcee.dispose();
      }
      if(screenSourcee!=null){
        Log.d("hamz->", " disposing screenSourcee"+screenSourcee.toString());
        screenSourcee.dispose();

      }
      if(screenTrackk!=null){
        Log.d("hamz->", " disposing screenTrackk"+screenTrackk.toString());

        screenTrackk.dispose();
      }
//      screenCaptureInstance.stopCapture();
//      screenCaptureInstance.dispose();
//      screenCaptureInstance=null;
    }

  }

  private VideoTrack createVideoTrack(AbstractVideoCaptureController videoCaptureController) {
//    Log.d("jam", "createVideoTrack: "+mediaProjectionPermissionResultData.toString());
    videoCaptureController.initializeVideoCapturer();
    VideoCapturer videoCapturer = videoCaptureController.videoCapturer;
    if (videoCapturer == null) {
      Log.d("hamz->", "video capturer is null: ");
      return null;
    }

    PeerConnectionFactory pcFactory = vdotokModule.mFactory;
    EglBase.Context eglContext = EglUtils.getRootEglBaseContext();
    SurfaceTextureHelper surfaceTextureHelper =
      SurfaceTextureHelper.create("CaptureThread", eglContext);
    if (surfaceTextureHelper == null) {
      Log.d(TAG, "Error creating SurfaceTextureHelper");
      Log.d("hamz->", "Error creating SurfaceTextureHelper");
      return null;
    }

    Log.d("hamz->", "creating video source: "+videoCapturer.isScreencast());
    VideoSource videoSource = pcFactory.createVideoSource(videoCapturer.isScreencast());
    videoCapturer.initialize(surfaceTextureHelper, reactContext, videoSource.getCapturerObserver());
    String id = UUID.randomUUID().toString();
    VideoTrack track = pcFactory.createVideoTrack(id, videoSource);

    track.setEnabled(true);
    tracks.put(id, new TrackPrivate(track, videoSource, videoCaptureController, surfaceTextureHelper));

    videoCaptureController.startCapture();
     screenSourcee=videoSource;
     screenTrackk=track;

    return track;
  }

  /**
   * Application/library-specific private members of local
   * {@code MediaStreamTrack}s created by {@code GetUserMediaImpl}.
   */
  private static class TrackPrivate {
    /**
     * The {@code MediaSource} from which {@link #track} was created.
     */
    public final MediaSource mediaSource;

    public final MediaStreamTrack track;

    /**
     * The {@code VideoCapturer} from which {@link #mediaSource} was created
     * if {@link #track} is a {@link VideoTrack}.
     */
    public final AbstractVideoCaptureController videoCaptureController;

    private final SurfaceTextureHelper surfaceTextureHelper;

    /**
     * Whether this object has been disposed or not.
     */
    private boolean disposed;

    /**
     * Initializes a new {@code TrackPrivate} instance.
     *
     * @param track
     * @param mediaSource            the {@code MediaSource} from which the specified
     *                               {@code code} was created
     * @param videoCaptureController the {@code AbstractVideoCaptureController} from which the
     *                               specified {@code mediaSource} was created if the specified
     *                               {@code track} is a {@link VideoTrack}
     */
    public TrackPrivate(
      MediaStreamTrack track,
      MediaSource mediaSource,
      AbstractVideoCaptureController videoCaptureController,
      SurfaceTextureHelper surfaceTextureHelper) {
      this.track = track;
      this.mediaSource = mediaSource;
      this.videoCaptureController = videoCaptureController;
      this.surfaceTextureHelper = surfaceTextureHelper;
      this.disposed = false;
    }

    public void dispose() {
      if (!disposed) {
        if (videoCaptureController != null) {
          if (videoCaptureController.stopCapture()) {
            videoCaptureController.dispose();
          }
        }

        /*
         * As per webrtc library documentation - The caller still has ownership of {@code
         * surfaceTextureHelper} and is responsible for making sure surfaceTextureHelper.dispose() is
         * called. This also means that the caller can reuse the SurfaceTextureHelper to initialize a new
         * VideoCapturer once the previous VideoCapturer has been disposed. */

        if (surfaceTextureHelper != null) {
          surfaceTextureHelper.stopListening();
          surfaceTextureHelper.dispose();
        }

        mediaSource.dispose();
        track.dispose();
        disposed = true;
      }
    }
  }

  private interface BiConsumer<T, U> {
    void accept(T t, U u);
  }
}
