import AVFoundation
import AVKit
import Foundation
import React

class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverHandler {

    private var _player:AVPlayer?
    private var _playerItem:AVPlayerItem?
    private var _source:VideoSource?
    private var _playerBufferEmpty:Bool = true
    private var _playerLayer:AVPlayerLayer?
    
    private var _playerViewController:RCTVideoPlayerViewController?
    private var _videoURL:NSURL?
    
    /* DRM */
    private var _drm:DRMParams?
    
    /* Required to publish events */
    private var _eventDispatcher:RCTEventDispatcher?
    private var _videoLoadStarted:Bool = false
    
    private var _pendingSeek:Bool = false
    private var _pendingSeekTime:Float = 0.0
    private var _lastSeekTime:Float = 0.0
    
    /* For sending videoProgress events */
    private var _controls:Bool = false
    
    /* Keep track of any modifiers, need to be applied after each play */
    private var _volume:Float = 1.0
    private var _rate:Float = 1.0
    private var _maxBitRate:Float?
    
    private var _automaticallyWaitsToMinimizeStalling:Bool = true
    private var _muted:Bool = false
    private var _paused:Bool = false
    private var _repeat:Bool = false
    private var _allowsExternalPlayback:Bool = true
    private var _textTracks:[TextTrack]?
    private var _selectedTextTrackCriteria:SelectedTrackCriteria?
    private var _selectedAudioTrackCriteria:SelectedTrackCriteria?
    private var _playbackStalled:Bool = false
    private var _playInBackground:Bool = false
    private var _preventsDisplaySleepDuringVideoPlayback:Bool = true
    private var _preferredForwardBufferDuration:Float = 0.0
    private var _playWhenInactive:Bool = false
    private var _ignoreSilentSwitch:String! = "inherit" // inherit, ignore, obey
    private var _mixWithOthers:String! = "inherit" // inherit, mix, duck
    private var _resizeMode:String! = "AVLayerVideoGravityResizeAspectFill"
    private var _fullscreen:Bool = false
    private var _fullscreenAutorotate:Bool = true
    private var _fullscreenOrientation:String! = "all"
    private var _fullscreenPlayerPresented:Bool = false
    private var _filterName:String!
    private var _filterEnabled:Bool = false
    private var _presentingViewController:UIViewController?
    
    private var _resouceLoaderDelegate: RCTResourceLoaderDelegate?
    private var _playerObserver: RCTPlayerObserver = RCTPlayerObserver()
    
#if canImport(RCTVideoCache)
    private var _videoCache:RCTVideoCachingHandler = RCTVideoCachingHandler(self.playerItemPrepareText)
#endif
    
#if TARGET_OS_IOS
    private let _pip:RCTPictureInPicture = RCTPictureInPicture(self.onPictureInPictureStatusChanged, self.onRestoreUserInterfaceForPictureInPictureStop)
#endif
    
    // Events
    @objc var onVideoLoadStart: RCTDirectEventBlock?
    @objc var onVideoLoad: RCTDirectEventBlock?
    @objc var onVideoBuffer: RCTDirectEventBlock?
    @objc var onVideoError: RCTDirectEventBlock?
    @objc var onVideoProgress: RCTDirectEventBlock?
    @objc var onBandwidthUpdate: RCTDirectEventBlock?
    @objc var onVideoSeek: RCTDirectEventBlock?
    @objc var onVideoEnd: RCTDirectEventBlock?
    @objc var onTimedMetadata: RCTDirectEventBlock?
    @objc var onVideoAudioBecomingNoisy: RCTDirectEventBlock?
    @objc var onVideoFullscreenPlayerWillPresent: RCTDirectEventBlock?
    @objc var onVideoFullscreenPlayerDidPresent: RCTDirectEventBlock?
    @objc var onVideoFullscreenPlayerWillDismiss: RCTDirectEventBlock?
    @objc var onVideoFullscreenPlayerDidDismiss: RCTDirectEventBlock?
    @objc var onReadyForDisplay: RCTDirectEventBlock?
    @objc var onPlaybackStalled: RCTDirectEventBlock?
    @objc var onPlaybackResume: RCTDirectEventBlock?
    @objc var onPlaybackRateChange: RCTDirectEventBlock?
    @objc var onVideoExternalPlaybackChange: RCTDirectEventBlock?
    @objc var onPictureInPictureStatusChanged: RCTDirectEventBlock?
    @objc var onRestoreUserInterfaceForPictureInPictureStop: RCTDirectEventBlock?
    @objc var onGetLicense: RCTDirectEventBlock?
    
    init(eventDispatcher:RCTEventDispatcher!) {
        super.init(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
        
        _eventDispatcher = eventDispatcher
        
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(applicationWillResignActive(notification:)),
            name: UIApplication.willResignActiveNotification,
            object: nil
        )
        
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(applicationDidEnterBackground(notification:)),
            name: UIApplication.didEnterBackgroundNotification,
            object: nil
        )
        
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(applicationWillEnterForeground(notification:)),
            name: UIApplication.willEnterForegroundNotification,
            object: nil
        )
        
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(audioRouteChanged(notification:)),
            name: AVAudioSession.routeChangeNotification,
            object: nil
        )
        _playerObserver._handlers = self
    }
    
    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
    }
    
    deinit {
        NotificationCenter.default.removeObserver(self)
        self.removePlayerLayer()
        _playerObserver.clearPlayer()
    }
    
    // MARK: - App lifecycle handlers
    
    @objc func applicationWillResignActive(notification:NSNotification!) {
        if _playInBackground || _playWhenInactive || _paused {return}
        
        _player?.pause()
        _player?.rate = 0.0
    }
    
    @objc func applicationDidEnterBackground(notification:NSNotification!) {
        if _playInBackground {
            // Needed to play sound in background. See https://developer.apple.com/library/ios/qa/qa1668/_index.html
            _playerLayer?.player = nil
            _playerViewController?.player = nil
        }
    }
    
    @objc func applicationWillEnterForeground(notification:NSNotification!) {
        self.applyModifiers()
        if _playInBackground {
            _playerLayer?.player = _player
            _playerViewController?.player = _player
        }
    }
    
    // MARK: - Audio events
    
    @objc func audioRouteChanged(notification:NSNotification!) {
        if let userInfo = notification.userInfo {
            let reason:AVAudioSession.RouteChangeReason! = userInfo[AVAudioSessionRouteChangeReasonKey] as? AVAudioSession.RouteChangeReason
            //            let previousRoute:NSNumber! = userInfo[AVAudioSessionRouteChangePreviousRouteKey] as? NSNumber
            if reason == .oldDeviceUnavailable, let onVideoAudioBecomingNoisy = onVideoAudioBecomingNoisy {
                onVideoAudioBecomingNoisy(["target": reactTag as Any])
            }
        }
    }
    
    // MARK: - Progress
    
    func sendProgressUpdate() {
        if let video = _player?.currentItem,
           video == nil || video.status != AVPlayerItem.Status.readyToPlay {
            return
        }
        
        let playerDuration:CMTime = RCTVideoUtils.playerItemDuration(_player)
        if CMTIME_IS_INVALID(playerDuration) {
            return
        }
        
        let currentTime = _player?.currentTime()
        let currentPlaybackTime = _player?.currentItem?.currentDate()
        let duration = CMTimeGetSeconds(playerDuration)
        let currentTimeSecs = CMTimeGetSeconds(currentTime ?? .zero)
        
        NotificationCenter.default.post(name: NSNotification.Name("RCTVideo_progress"), object: nil, userInfo: [
            "progress": NSNumber(value: currentTimeSecs / duration)
        ])
        
        if currentTimeSecs >= 0 {
            onVideoProgress?([
                "currentTime": NSNumber(value: Float(currentTimeSecs)),
                "playableDuration": RCTVideoUtils.calculatePlayableDuration(_player),
                "atValue": NSNumber(value: currentTime?.value ?? .zero),
                "currentPlaybackTime": NSNumber(value: NSNumber(value: floor(currentPlaybackTime?.timeIntervalSince1970 ?? 0 * 1000)).int64Value),
                "target": reactTag,
                "seekableDuration": RCTVideoUtils.calculateSeekableDuration(_player)
            ])
        }
    }
    
    // MARK: - Player and source
    
    @objc
    func setSrc(_ source:NSDictionary!) {
        _source = VideoSource(source)
        removePlayerLayer()
        _playerObserver.player = nil
        _playerObserver.playerItem = nil
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + Double(Int64(0)) / Double(NSEC_PER_SEC), execute: { [weak self] in
            guard let self = self else {return}
            // perform on next run loop, otherwise other passed react-props may not be set
            self.playerItemForSource(withCallback:{ (playerItem:AVPlayerItem!) in
                self._player?.pause()
                self._playerItem = playerItem
                self._playerObserver.playerItem = self._playerItem
                self.setPreferredForwardBufferDuration(self._preferredForwardBufferDuration)
                self.setFilter(self._filterName)
                if let maxBitRate = self._maxBitRate {
                    self._playerItem?.preferredPeakBitRate = Double(maxBitRate)
                }
                
                self._player = AVPlayer(playerItem: self._playerItem)
                self._playerObserver.player = self._player
                
                self._player?.actionAtItemEnd = .none

                if #available(iOS 10.0, *) {
                    self.setAutomaticallyWaitsToMinimizeStalling(self._automaticallyWaitsToMinimizeStalling)
                }
                
                //Perform on next run loop, otherwise onVideoLoadStart is nil
                self.onVideoLoadStart?([
                    "src": [
                        "uri": self._source?.uri ?? NSNull(),
                        "type": self._source?.type ?? NSNull(),
                        "isNetwork": NSNumber(value: self._source?.isNetwork ?? false)
                    ],
                    "drm": self._drm?.json ?? NSNull(),
                    "target": self.reactTag
                ])
                
            })
        })
        _videoLoadStarted = true
    }
    
    @objc
    func setDrm(_ drm:NSDictionary!) {
        _drm = DRMParams(drm)
    }
    
    func playerItemPrepareText(asset:AVAsset!, assetOptions:NSDictionary?, withCallback handler:(AVPlayerItem?)->Void) {
        if (_textTracks == nil) || _textTracks?.count==0 {
            handler(AVPlayerItem(asset: asset))
            return
        }
        
        // AVPlayer can't airplay AVMutableCompositions
        _allowsExternalPlayback = false
        
        // sideload text tracks
        let mixComposition:AVMutableComposition! = AVMutableComposition()
        
        let videoAsset:AVAssetTrack! = asset.tracks(withMediaType: AVMediaType.video).first
        let videoCompTrack:AVMutableCompositionTrack! = mixComposition.addMutableTrack(withMediaType: AVMediaType.video, preferredTrackID:kCMPersistentTrackID_Invalid)
        do {
            try videoCompTrack.insertTimeRange(
                CMTimeRangeMake(start: .zero, duration: videoAsset.timeRange.duration),
                of: videoAsset,
                at: .zero)
        } catch {
        }
        
        let audioAsset:AVAssetTrack! = asset.tracks(withMediaType: AVMediaType.audio).first
        let audioCompTrack:AVMutableCompositionTrack! = mixComposition.addMutableTrack(withMediaType: AVMediaType.audio, preferredTrackID:kCMPersistentTrackID_Invalid)
        do {
            try audioCompTrack.insertTimeRange(
                CMTimeRangeMake(start: .zero, duration: videoAsset.timeRange.duration),
                of: audioAsset,
                at: .zero)
        } catch {
        }
        
        var validTextTracks:[TextTrack] = []
        if let textTracks = _textTracks, let textTrackCount = _textTracks?.count {
            for i in 0..<textTracks.count {
                var textURLAsset:AVURLAsset!
                let textUri:String = textTracks[i].uri
                if textUri.lowercased().hasPrefix("http") {
                    textURLAsset = AVURLAsset(url: NSURL(string: textUri)! as URL, options:(assetOptions as! [String : Any]))
                } else {
                    textURLAsset = AVURLAsset(url: RCTVideoUtils.urlFilePath(filepath: textUri as NSString?) as URL, options:nil)
                }
                let textTrackAsset:AVAssetTrack! = textURLAsset.tracks(withMediaType: AVMediaType.text).first
                if (textTrackAsset == nil) {continue} // fix when there's no textTrackAsset
                validTextTracks.append(textTracks[i])
                let textCompTrack:AVMutableCompositionTrack! = mixComposition.addMutableTrack(withMediaType: AVMediaType.text,
                                                                                              preferredTrackID:kCMPersistentTrackID_Invalid)
                do {
                    try textCompTrack.insertTimeRange(
                        CMTimeRangeMake(start: .zero, duration: videoAsset.timeRange.duration),
                        of: textTrackAsset,
                        at: .zero)
                } catch {
                }
            }
        }
        if validTextTracks.count != _textTracks?.count {
            setTextTracks(validTextTracks)
        }
        
        handler(AVPlayerItem(asset: mixComposition))
    }
    
    func playerItemForSource(withCallback handler:(AVPlayerItem?)->Void) {
        var asset:AVURLAsset!
        guard let source = _source, source.uri != nil && source.uri != "" else {
            DebugLog("Could not find video URL in source '\(_source)'")
            return
        }
        
        let bundlePath = Bundle.main.path(forResource: source.uri, ofType: source.type) ?? ""
        let url = source.isNetwork || source.isAsset
        ? URL(string: source.uri ?? "")
        : URL(fileURLWithPath: bundlePath)
        
        let assetOptions:NSMutableDictionary! = NSMutableDictionary()
        
        if url != nil && source.isNetwork {
            if let headers = source.requestHeaders, headers.count > 0 {
                assetOptions.setObject(headers, forKey:"AVURLAssetHTTPHeaderFieldsKey" as NSCopying)
            }
            let cookies:[AnyObject]! = HTTPCookieStorage.shared.cookies
            assetOptions.setObject(cookies, forKey:AVURLAssetHTTPCookiesKey as NSCopying)
#if canImport(RCTVideoCache)
            if _videoCache.playerItemForSourceUsingCache(shouldCache:shouldCache, textTracks:_textTracks, uri:uri, assetOptions:assetOptions, handler:handler) {
                return
            }
#endif
            
            asset = AVURLAsset(url: url!, options:assetOptions as! [String : Any])
        } else {
            asset = AVURLAsset(url: url!)
        }
        
        if _drm != nil {
            _resouceLoaderDelegate = RCTResourceLoaderDelegate(
                asset: asset,
                drm: _drm,
                onVideoError: onVideoError,
                onGetLicense: onGetLicense,
                reactTag: reactTag
            )
        }
        
        self.playerItemPrepareText(asset: asset, assetOptions:assetOptions, withCallback:handler)
    }
    
    // MARK: - Prop setters
    
    @objc
    func setResizeMode(_ mode: String?) {
        if _controls {
            _playerViewController?.videoGravity = AVLayerVideoGravity(rawValue: mode ?? "")
        } else {
            _playerLayer?.videoGravity = AVLayerVideoGravity(rawValue: mode ?? "")
        }
        _resizeMode = mode
    }
    
    @objc
    func setPlayInBackground(_ playInBackground:Bool) {
        _playInBackground = playInBackground
    }
    
    @objc
    func setPreventsDisplaySleepDuringVideoPlayback(_ preventsDisplaySleepDuringVideoPlayback:Bool) {
        _preventsDisplaySleepDuringVideoPlayback = preventsDisplaySleepDuringVideoPlayback
        self.applyModifiers()
    }
    
    @objc
    func setAllowsExternalPlayback(_ allowsExternalPlayback:Bool) {
        _allowsExternalPlayback = allowsExternalPlayback
        _player?.allowsExternalPlayback = _allowsExternalPlayback
    }
    
    @objc
    func setPlayWhenInactive(_ playWhenInactive:Bool) {
        _playWhenInactive = playWhenInactive
    }
    
    @objc
    func setPictureInPicture(_ pictureInPicture:Bool) {
#if TARGET_OS_IOS
        _pip.setPictureInPicture(pictureInPicture)
#endif
    }
    
    @objc
    func setRestoreUserInterfaceForPIPStopCompletionHandler(_ restore:Bool) {
#if TARGET_OS_IOS
        _pip.setRestoreUserInterfaceForPIPStopCompletionHandler(restore)
#endif
    }
    
    @objc
    func setIgnoreSilentSwitch(_ ignoreSilentSwitch:String!) {
        _ignoreSilentSwitch = ignoreSilentSwitch
        self.applyModifiers()
    }
    
    @objc
    func setMixWithOthers(_ mixWithOthers:String!) {
        _mixWithOthers = mixWithOthers
        self.applyModifiers()
    }
    
    @objc
    func setPaused(_ paused:Bool) {
        if paused {
            _player?.pause()
            _player?.rate = 0.0
        } else {
            let session:AVAudioSession! = AVAudioSession.sharedInstance()
            var category:AVAudioSession.Category? = nil
            var options:AVAudioSession.CategoryOptions? = nil
            
            if (_ignoreSilentSwitch == "ignore") {
                category = AVAudioSession.Category.playback
            } else if (_ignoreSilentSwitch == "obey") {
                category = AVAudioSession.Category.ambient
            }
            
            if (_mixWithOthers == "mix") {
                options = .mixWithOthers
            } else if (_mixWithOthers == "duck") {
                options = .duckOthers
            }
            
            if let category = category, let options = options {
                do {
                    try session.setCategory(category, options: options)
                } catch {
                }
            } else if let category = category, options == nil {
                do {
                    try session.setCategory(category)
                } catch {
                }
            } else if category == nil, let options = options {
                do {
                    try session.setCategory(session.category, options: options)
                } catch {
                }
            }
            
            if #available(iOS 10.0, *), !_automaticallyWaitsToMinimizeStalling {
                _player?.playImmediately(atRate: _rate)
            } else {
                _player?.play()
                _player?.rate = _rate
            }
            _player?.rate = _rate
        }
        
        _paused = paused
    }
    
    @objc
    func setCurrentTime(_ currentTime:Float) {
        let info:NSDictionary! = [
            "time": NSNumber(value: currentTime),
            "tolerance": NSNumber(value: 100)
        ]
        setSeek(info)
    }
    
    @objc
    func setSeek(_ info:NSDictionary!) {
        let seekTime:NSNumber! = info["time"] as! NSNumber
        let seekTolerance:NSNumber! = info["tolerance"] as! NSNumber
        
        let timeScale:Int = 1000
        
        let item:AVPlayerItem! = _player?.currentItem
        guard item != nil && item.status == AVPlayerItem.Status.readyToPlay else {
            _pendingSeek = true
            _pendingSeekTime = seekTime.floatValue
            return
        }
        
        // TODO check loadedTimeRanges
        let cmSeekTime:CMTime = CMTimeMakeWithSeconds(Float64(seekTime.floatValue), preferredTimescale: Int32(timeScale))
        let current:CMTime = item.currentTime()
        // TODO figure out a good tolerance level
        let tolerance:CMTime = CMTimeMake(value: Int64(seekTolerance.floatValue), timescale: Int32(timeScale))
        let wasPaused:Bool = _paused
        
        guard CMTimeCompare(current, cmSeekTime) != 0 else { return }
        if !wasPaused { _player?.pause() }
        
        _player?.seek(to: cmSeekTime, toleranceBefore:tolerance, toleranceAfter:tolerance, completionHandler:{ [weak self] (finished:Bool) in
            guard let self = self else { return }
            
            self._playerObserver.addTimeObserverIfNotSet()
            if !wasPaused {
                self.setPaused(false)
            }
            self.onVideoSeek?(["currentTime": NSNumber(value: Float(CMTimeGetSeconds(item.currentTime()))),
                               "seekTime": seekTime,
                               "target": self.reactTag])
        })
        
        _pendingSeek = false
    }
    
    @objc
    func setRate(_ rate:Float) {
        _rate = rate
        applyModifiers()
    }
    
    @objc
    func setMuted(_ muted:Bool) {
        _muted = muted
        applyModifiers()
    }
    
    @objc
    func setVolume(_ volume:Float) {
        _volume = volume
        applyModifiers()
    }
    
    @objc
    func setMaxBitRate(_ maxBitRate:Float) {
        _maxBitRate = maxBitRate
        _playerItem?.preferredPeakBitRate = Double(maxBitRate)
    }
    
    @objc
    func setPreferredForwardBufferDuration(_ preferredForwardBufferDuration:Float) {
        _preferredForwardBufferDuration = preferredForwardBufferDuration
        if #available(iOS 10.0, *) {
            _playerItem?.preferredForwardBufferDuration = TimeInterval(preferredForwardBufferDuration)
        } else {
            // Fallback on earlier versions
        }
    }
    
    @objc
    func setAutomaticallyWaitsToMinimizeStalling(_ waits:Bool) {
        _automaticallyWaitsToMinimizeStalling = waits
        if #available(iOS 10.0, *) {
            _player?.automaticallyWaitsToMinimizeStalling = waits
        } else {
            // Fallback on earlier versions
        }
    }
    
    
    func applyModifiers() {
        if _muted {
            if !_controls {
                _player?.volume = 0
            }
            _player?.isMuted = true
        } else {
            _player?.volume = _volume
            _player?.isMuted = false
        }
        
        if #available(iOS 12.0, *) {
            _player?.preventsDisplaySleepDuringVideoPlayback = _preventsDisplaySleepDuringVideoPlayback
        } else {
            // Fallback on earlier versions
        }
        
        if let _maxBitRate = _maxBitRate {
            setMaxBitRate(_maxBitRate)
        }
        
        setSelectedAudioTrack(_selectedAudioTrackCriteria)
        setSelectedTextTrack(_selectedTextTrackCriteria)
        setResizeMode(_resizeMode)
        setRepeat(_repeat)
        setPaused(_paused)
        setControls(_controls)
        setAllowsExternalPlayback(_allowsExternalPlayback)
    }
    
    @objc
    func setRepeat(_ `repeat`: Bool) {
        _repeat = `repeat`
    }
    

    
    @objc
    func setSelectedAudioTrack(_ selectedAudioTrack:NSDictionary!) {
        setSelectedAudioTrack(SelectedTrackCriteria(selectedAudioTrack))
    }
    
    func setSelectedAudioTrack(_ selectedAudioTrack:SelectedTrackCriteria!) {
        _selectedAudioTrackCriteria = selectedAudioTrack
        RCTPlayerOperations.setMediaSelectionTrackForCharacteristic(player:_player, characteristic: AVMediaCharacteristic.audible,
                                                     criteria:_selectedAudioTrackCriteria)
    }
    
    @objc
    func setSelectedTextTrack(_ selectedTextTrack:NSDictionary!) {
        setSelectedTextTrack(SelectedTrackCriteria(selectedTextTrack))
    }
    
    func setSelectedTextTrack(_ selectedTextTrack:SelectedTrackCriteria!) {
        _selectedTextTrackCriteria = selectedTextTrack
        if (_textTracks != nil) { // sideloaded text tracks
            RCTPlayerOperations.setSideloadedText(player:_player, textTracks:_textTracks, criteria:_selectedTextTrackCriteria)
        } else { // text tracks included in the HLS playlist
            RCTPlayerOperations.setMediaSelectionTrackForCharacteristic(player:_player, characteristic: AVMediaCharacteristic.legible,
                                                         criteria:_selectedTextTrackCriteria)
        }
    }
    
    @objc
    func setTextTracks(_ textTracks:[NSDictionary]!) {
        setTextTracks(textTracks.map { TextTrack($0) })
    }
    
    func setTextTracks(_ textTracks:[TextTrack]!) {
        _textTracks = textTracks
        
        // in case textTracks was set after selectedTextTrack
        if (_selectedTextTrackCriteria != nil) {setSelectedTextTrack(_selectedTextTrackCriteria)}
    }

    @objc
    func setFullscreen(_ fullscreen:Bool) {
        if fullscreen && !_fullscreenPlayerPresented && _player != nil {
            // Ensure player view controller is not null
            if _playerViewController == nil {
                self.usePlayerViewController()
            }
            
            // Set presentation style to fullscreen
            _playerViewController?.modalPresentationStyle = .fullScreen
            
            // Find the nearest view controller
            var viewController:UIViewController! = self.firstAvailableUIViewController()
            if (viewController == nil) {
                let keyWindow:UIWindow! = UIApplication.shared.keyWindow
                viewController = keyWindow.rootViewController
                if viewController.children.count > 0
                {
                    viewController = viewController.children.last
                }
            }
            if viewController != nil {
                _presentingViewController = viewController
                
                self.onVideoFullscreenPlayerWillPresent?(["target": reactTag as Any])
                
                viewController.present(viewController, animated:true, completion:{
                    self._playerViewController?.showsPlaybackControls = true
                    self._fullscreenPlayerPresented = fullscreen
                    self._playerViewController?.autorotate = self._fullscreenAutorotate
                    
                    self.onVideoFullscreenPlayerDidPresent?(["target": self.reactTag])
                    
                })
            }
        } else if !fullscreen && _fullscreenPlayerPresented, let _playerViewController = _playerViewController {
            self.videoPlayerViewControllerWillDismiss(playerViewController: _playerViewController)
            _presentingViewController?.dismiss(animated: true, completion:{
                self.videoPlayerViewControllerDidDismiss(playerViewController: _playerViewController)
            })
        }
    }
    
    @objc
    func setFullscreenAutorotate(_ autorotate:Bool) {
        _fullscreenAutorotate = autorotate
        if _fullscreenPlayerPresented {
            _playerViewController?.autorotate = autorotate
        }
    }
    
    @objc
    func setFullscreenOrientation(_ orientation:String!) {
        _fullscreenOrientation = orientation
        if _fullscreenPlayerPresented {
            _playerViewController?.preferredOrientation = orientation
        }
    }
    
    func usePlayerViewController() {
        guard _player != nil else { return }
        
        if _playerViewController == nil {
            _playerViewController = createPlayerViewController(player: _player, withPlayerItem:_playerItem)
            
        }
        // to prevent video from being animated when resizeMode is 'cover'
        // resize mode must be set before subview is added
        setResizeMode(_resizeMode)
        
        guard let _playerViewController = _playerViewController else { return }

        if _controls {
            let viewController:UIViewController! = self.reactViewController()
            viewController.addChild(_playerViewController)
            self.addSubview(_playerViewController.view)
        }
        
        _playerObserver.playerViewController = _playerViewController
    }
    
    func createPlayerViewController(player:AVPlayer!, withPlayerItem playerItem:AVPlayerItem!) -> RCTVideoPlayerViewController! {
        let viewController:RCTVideoPlayerViewController! = RCTVideoPlayerViewController()
        viewController.showsPlaybackControls = true
        viewController.rctDelegate = self
        viewController.preferredOrientation = _fullscreenOrientation
        
        viewController.view.frame = self.bounds
        viewController.player = player
        return viewController
    }
    
    func usePlayerLayer() {
        if let _player = _player {
            _playerLayer = AVPlayerLayer(player: _player)
            _playerLayer?.frame = self.bounds
            _playerLayer?.needsDisplayOnBoundsChange = true
            
            // to prevent video from being animated when resizeMode is 'cover'
            // resize mode must be set before layer is added
            setResizeMode(_resizeMode)
            _playerObserver.playerLayer = _playerLayer
            
            if let _playerLayer = _playerLayer {
                self.layer.addSublayer(_playerLayer)
            }
            self.layer.needsDisplayOnBoundsChange = true
#if TARGET_OS_IOS
            _pip.setupPipController(_playerLayer)
#endif
        }
    }
    
    @objc
    func setControls(_ controls:Bool) {
        if _controls != controls || ((_playerLayer == nil) && (_playerViewController == nil))
        {
            _controls = controls
            if _controls
            {
                self.removePlayerLayer()
                self.usePlayerViewController()
            }
            else
            {
                _playerViewController?.view.removeFromSuperview()
                _playerViewController = nil
                _playerObserver.playerViewController = nil
                self.usePlayerLayer()
            }
        }
    }
    
    @objc
    func setProgressUpdateInterval(_ progressUpdateInterval:Float) {
        _playerObserver.replaceTimeObserverIfSet(Float64(progressUpdateInterval))
    }
    
    func removePlayerLayer() {
        _resouceLoaderDelegate = nil
        _playerLayer?.removeFromSuperlayer()
        _playerLayer = nil
        _playerObserver.playerLayer = nil
    }
    
    // MARK: - RCTVideoPlayerViewControllerDelegate
    
    func videoPlayerViewControllerWillDismiss(playerViewController:AVPlayerViewController) {
        if _playerViewController == playerViewController && _fullscreenPlayerPresented, let onVideoFullscreenPlayerWillDismiss = onVideoFullscreenPlayerWillDismiss {
            _playerObserver.removePlayerViewControllerObservers()
            onVideoFullscreenPlayerWillDismiss(["target": reactTag as Any])
        }
    }
    
    
    func videoPlayerViewControllerDidDismiss(playerViewController:AVPlayerViewController) {
        if _playerViewController == playerViewController && _fullscreenPlayerPresented {
            _fullscreenPlayerPresented = false
            _presentingViewController = nil
            _playerViewController = nil
            _playerObserver.playerViewController = nil
            self.applyModifiers()
            
            onVideoFullscreenPlayerDidDismiss?(["target": reactTag as Any])
        }
    }
    
    @objc
    func setFilter(_ filterName:String!) {
        _filterName = filterName
        
        if !_filterEnabled {
            return
        } else if let uri = _source?.uri, uri.contains("m3u8") {
            return // filters don't work for HLS... return
        } else if _playerItem?.asset == nil {
            return
        }
        
        let filter:CIFilter! = CIFilter(name: filterName)
        if #available(iOS 9.0, *), let _playerItem = _playerItem {
            self._playerItem?.videoComposition = AVVideoComposition(
                asset: _playerItem.asset,
                applyingCIFiltersWithHandler: { (request:AVAsynchronousCIImageFilteringRequest) in
                    if filter == nil {
                        request.finish(with: request.sourceImage, context:nil)
                    } else {
                        let image:CIImage! = request.sourceImage.clampedToExtent()
                        filter.setValue(image, forKey:kCIInputImageKey)
                        let output:CIImage! = filter.outputImage?.cropped(to: request.sourceImage.extent)
                        request.finish(with: output, context:nil)
                    }
                })
        } else {
            // Fallback on earlier versions
        }
    }
    
    @objc
    func setFilterEnabled(_ filterEnabled:Bool) {
        _filterEnabled = filterEnabled
    }
    
    // MARK: - React View Management
    
    func insertReactSubview(view:UIView!, atIndex:Int) {
        // We are early in the game and somebody wants to set a subview.
        // That can only be in the context of playerViewController.
        if !_controls && (_playerLayer == nil) && (_playerViewController == nil) {
            setControls(true)
        }
        
        if _controls {
            view.frame = self.bounds
            _playerViewController?.contentOverlayView?.insertSubview(view, at:atIndex)
        } else {
            RCTLogError("video cannot have any subviews")
        }
        return
    }
    
    func removeReactSubview(subview:UIView!) {
        if _controls {
            subview.removeFromSuperview()
        } else {
            RCTLog("video cannot have any subviews")
        }
        return
    }
    
    override func layoutSubviews() {
        super.layoutSubviews()
        if _controls, let _playerViewController = _playerViewController {
            _playerViewController.view.frame = bounds
            
            // also adjust all subviews of contentOverlayView
            for subview in _playerViewController.contentOverlayView?.subviews ?? [] {
                subview.frame = bounds
            }
        } else {
            CATransaction.begin()
            CATransaction.setAnimationDuration(0)
            _playerLayer?.frame = bounds
            CATransaction.commit()
        }
    }
    
    // MARK: - Lifecycle
    
    override func removeFromSuperview() {
        _player?.pause()
        _player = nil
        _playerObserver.clearPlayer()
        
        self.removePlayerLayer()
        
        if let _playerViewController = _playerViewController {
            _playerViewController.view.removeFromSuperview()
            _playerViewController.rctDelegate = nil
            _playerViewController.player = nil
            self._playerViewController = nil
            _playerObserver.playerViewController = nil
        }
        
        _eventDispatcher = nil
        NotificationCenter.default.removeObserver(self)
        
        super.removeFromSuperview()
    }
    
    // MARK: - Export
    
    @objc
    func save(options:NSDictionary!, resolve: @escaping RCTPromiseResolveBlock, reject:@escaping RCTPromiseRejectBlock) {
        RCTVideoSave.save(
            options:options,
            resolve:resolve,
            reject:reject,
            playerItem:_playerItem
        )
    }
    
    func setLicenseResult(_ license:String!) {
        _resouceLoaderDelegate?.setLicenseResult(license)
    }
    
    func setLicenseResultError(_ error:String!) {
        _resouceLoaderDelegate?.setLicenseResultError(error)
    }
    
    // MARK: - RCTPlayerObserverHandler
    
    func handleTimeUpdate(time:CMTime) {
        sendProgressUpdate()
    }
    
    func handleReadyForDisplay(changeObject: Any, change:NSKeyValueObservedChange<Bool>) {
        onReadyForDisplay?([
            "target": reactTag
        ])
    }
    
    // When timeMetadata is read the event onTimedMetadata is triggered
    func handleTimeMetadataChange(playerItem:AVPlayerItem, change:NSKeyValueObservedChange<[AVMetadataItem]?>) {
        guard let newValue = change.newValue, let _items = newValue, _items.count > 0 else {
            return
        }
        
         var metadata: [[String:String?]?] = []
         for item in _items {
             let value = item.value as? String
             let identifier = item.identifier?.rawValue
            
             if let value = value {
                 metadata.append(["value":value, "identifier":identifier])
             }
         }
        
         onTimedMetadata?([
             "target": reactTag,
             "metadata": metadata
         ])
    }
    
    // Handle player item status change.
    func handlePlayerItemStatusChange(playerItem:AVPlayerItem, change:NSKeyValueObservedChange<AVPlayerItem.Status>) {
        guard let _playerItem = _playerItem else {
            return
        }
        
        if _playerItem.status == .readyToPlay {
            handleReadyToPlay()
        } else if _playerItem.status == .failed {
            handlePlaybackFailed()
        }
    }
    
    func handleReadyToPlay() {
        guard let _playerItem = _playerItem else { return }
        var duration:Float = Float(CMTimeGetSeconds(_playerItem.asset.duration))
        
        if duration.isNaN {
            duration = 0.0
        }
        
        var width: Float? = nil
        var height: Float? = nil
        var orientation = "undefined"
        
        if _playerItem.asset.tracks(withMediaType: AVMediaType.video).count > 0 {
            let videoTrack = _playerItem.asset.tracks(withMediaType: .video)[0]
            width = Float(videoTrack.naturalSize.width)
            height = Float(videoTrack.naturalSize.height)
            let preferredTransform = videoTrack.preferredTransform
            
            if (videoTrack.naturalSize.width == preferredTransform.tx
                && videoTrack.naturalSize.height == preferredTransform.ty)
                || (preferredTransform.tx == 0 && preferredTransform.ty == 0)
            {
                orientation = "landscape"
            } else {
                orientation = "portrait"
            }
        } else if _playerItem.presentationSize.height != 0.0 {
            width = Float(_playerItem.presentationSize.width)
            height = Float(_playerItem.presentationSize.height)
            orientation = _playerItem.presentationSize.width > _playerItem.presentationSize.height ? "landscape" : "portrait"
        }
        
        if _pendingSeek {
            setCurrentTime(_pendingSeekTime)
            _pendingSeek = false
        }
        
        if _videoLoadStarted {
            onVideoLoad?(["duration": NSNumber(value: duration),
                          "currentTime": NSNumber(value: Float(CMTimeGetSeconds(_playerItem.currentTime()))),
                          "canPlayReverse": NSNumber(value: _playerItem.canPlayReverse),
                          "canPlayFastForward": NSNumber(value: _playerItem.canPlayFastForward),
                          "canPlaySlowForward": NSNumber(value: _playerItem.canPlaySlowForward),
                          "canPlaySlowReverse": NSNumber(value: _playerItem.canPlaySlowReverse),
                          "canStepBackward": NSNumber(value: _playerItem.canStepBackward),
                          "canStepForward": NSNumber(value: _playerItem.canStepForward),
                          "naturalSize": [
                            "width": width != nil ? NSNumber(value: width!) : "undefinded",
                            "height": width != nil ? NSNumber(value: height!) : "undefinded",
                            "orientation": orientation
                          ],
                          "audioTracks": RCTVideoUtils.getAudioTrackInfo(_player),
                          "textTracks": _textTracks ?? RCTVideoUtils.getTextTrackInfo(_player),
                          "target": reactTag as Any])
        }
        _videoLoadStarted = false
        _playerObserver.attachPlayerEventListeners()
        applyModifiers()
    }
    
    func handlePlaybackFailed() {
        guard let _playerItem = _playerItem else { return }
        onVideoError?(
            [
                "error": [
                    "code": NSNumber(value: (_playerItem.error! as NSError).code),
                    "localizedDescription": _playerItem.error?.localizedDescription == nil ? "" : _playerItem.error?.localizedDescription,
                    "localizedFailureReason": ((_playerItem.error! as NSError).localizedFailureReason == nil ? "" : (_playerItem.error! as NSError).localizedFailureReason) ?? "",
                    "localizedRecoverySuggestion": ((_playerItem.error! as NSError).localizedRecoverySuggestion == nil ? "" : (_playerItem.error! as NSError).localizedRecoverySuggestion) ?? "",
                    "domain": (_playerItem.error as! NSError).domain
                ],
                "target": reactTag
            ])
    }
    
    func handlePlaybackBufferKeyEmpty(playerItem:AVPlayerItem, change:NSKeyValueObservedChange<Bool>) {
        _playerBufferEmpty = true
        onVideoBuffer?(["isBuffering": true, "target": reactTag as Any])
    }
    
    // Continue playing (or not if paused) after being paused due to hitting an unbuffered zone.
    func handlePlaybackLikelyToKeepUp(playerItem:AVPlayerItem, change:NSKeyValueObservedChange<Bool>) {
        if (!(_controls || _fullscreenPlayerPresented) || _playerBufferEmpty) && ((_playerItem?.isPlaybackLikelyToKeepUp) != nil) {
            setPaused(_paused)
        }
        _playerBufferEmpty = false
        onVideoBuffer?(["isBuffering": false, "target": reactTag as Any])
    }
    
    func handlePlaybackRateChange(player: AVPlayer, change: NSKeyValueObservedChange<Float>) {
        guard let _player = _player else { return }
        onPlaybackRateChange?(["playbackRate": NSNumber(value: _player.rate),
                               "target": reactTag as Any])
        if _playbackStalled && _player.rate > 0 {
            onPlaybackResume?(["playbackRate": NSNumber(value: _player.rate),
                               "target": reactTag as Any])
            _playbackStalled = false
        }
    }
    
    func handleExternalPlaybackActiveChange(player: AVPlayer, change: NSKeyValueObservedChange<Bool>) {
        guard let _player = _player else { return }
        onVideoExternalPlaybackChange?(["isExternalPlaybackActive": NSNumber(value: _player.isExternalPlaybackActive),
                                        "target": reactTag as Any])
    }
    
    func handleViewControllerOverlayViewFrameChange(overlayView:UIView, change:NSKeyValueObservedChange<CGRect>) {
        let oldRect = change.oldValue
        let newRect = change.newValue
        if !oldRect!.equalTo(newRect!) {
            if newRect!.equalTo(UIScreen.main.bounds) {
                NSLog("in fullscreen")
                
                self.reactViewController().view.frame = UIScreen.main.bounds
                self.reactViewController().view.setNeedsLayout()
            } else {NSLog("not fullscreen")}
        }
    }
    
    @objc func handleDidFailToFinishPlaying(notification:NSNotification!) {
        let error:NSError! = notification.userInfo?[AVPlayerItemFailedToPlayToEndTimeErrorKey] as? NSError
        onVideoError?(
            [
                "error": [
                    "code": NSNumber(value: (error as NSError).code),
                    "localizedDescription": error.localizedDescription ?? "",
                    "localizedFailureReason": (error as NSError).localizedFailureReason ?? "",
                    "localizedRecoverySuggestion": (error as NSError).localizedRecoverySuggestion ?? "",
                    "domain": (error as NSError).domain
                ],
                "target": reactTag
            ])
    }
    
    @objc func handlePlaybackStalled(notification:NSNotification!) {
        onPlaybackStalled?(["target": reactTag as Any])
        _playbackStalled = true
    }
    
    @objc func handlePlayerItemDidReachEnd(notification:NSNotification!) {
        onVideoEnd?(["target": reactTag as Any])
        
        if _repeat {
            let item:AVPlayerItem! = notification.object as? AVPlayerItem
            item.seek(to: CMTime.zero)
            self.applyModifiers()
        } else {
            _playerObserver.removePlayerTimeObserver()
        }
    }
    
    //unused
//    @objc func handleAVPlayerAccess(notification:NSNotification!) {
//        let accessLog:AVPlayerItemAccessLog! = (notification.object as! AVPlayerItem).accessLog()
//        let lastEvent:AVPlayerItemAccessLogEvent! = accessLog.events.last
//        
//        /* TODO: get this working
//         if (self.onBandwidthUpdate) {
//         self.onBandwidthUpdate(@{@"bitrate": [NSNumber numberWithFloat:lastEvent.observedBitrate]});
//         }
//         */
//    }
}