Woka_Native_iOS/WOKA/Theme/Controller/PlayerVC.swift

//
//  PlayerVC.swift
//  WOKA
//
//  Created by MacBook Pro on 30/05/24.


import UIKit
import JWPlayerKit
import AVKit

class PlayerVC: JWPlayerViewController, JWPlayerViewControllerDelegate {

    @IBOutlet weak var innerPlayerView: UIView!
    var previousScale: CGFloat = 1.0
//    let backButton = UIButton(type: .system)
    var config: JWPlayerConfiguration!
    var dismissTapped: (() -> Void)?
    var videoIndex : Int?
    
    func rotateToLandsScapeDevice(){
        let appDelegate = UIApplication.shared.delegate as! AppDelegate
        appDelegate.myOrientation = .landscapeRight
        if #available(iOS 16.0, *) {
            let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene
            windowScene?.requestGeometryUpdate(.iOS(interfaceOrientations: UIInterfaceOrientationMask.landscapeRight))
        } else {
            UIDevice.current.setValue(UIInterfaceOrientationMask.landscapeRight.rawValue, forKey: "orientation")
        }
        UIView.setAnimationsEnabled(true)
    }

    
    func rotateToPotraitScapeDevice(){
        
        let appDelegate = UIApplication.shared.delegate as! AppDelegate
        appDelegate.myOrientation = .portrait
        if #available(iOS 16.0, *) {
            let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene
            windowScene?.requestGeometryUpdate(.iOS(interfaceOrientations: UIInterfaceOrientationMask.portrait))
        } else {
            UIDevice.current.setValue(UIInterfaceOrientationMask.landscapeRight.rawValue, forKey: "orientation")
        }
//        UIDevice.current.setValue(UIInterfaceOrientation.portrait.rawValue, forKey: "orientation")
        UIView.setAnimationsEnabled(true)
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        player.configurePlayer(with: config)

        self.rotateToLandsScapeDevice()
        self.delegate = self

        //Disable Picture in Picture
        playerView.allowsPictureInPicturePlayback = false
//        playerView.captionStyle = .none
    }

    @objc func applicationDidBecomeActive() {
        self.setDeviceOrientation(orientation: .landscapeRight)
    }
    
    override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
        if size.width > self.view.frame.size.width {
            print("Landscape")
        } else {
            DispatchQueue.main.async {
                self.dismiss(animated: true)
            }
        }
    }
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
//        self.navigationController?.isNavigationBarHidden = true
    }
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        player.stop()
    }

    // MARK: - JWPlayerViewControllerDelegate

    override func jwplayer(_ player: any JWPlayer, didFinishLoadingWithTime loadTime: TimeInterval) {
        super.jwplayer(player, didFinishLoadingWithTime: loadTime)
        print("LoadTime", loadTime)
//        self.player.play()
    }
    
    //Playlist Functions
//    
//    override func jwplayer(_ player: any JWPlayer, didLoadPlaylist playlist: [JWPlayerItem]) {
//        print("DidLoad", playlist.count , playlist)
////        player.loadPlayerItemAt(index: videoIndex ?? 0)
////        player.play(relatedContent: videoIndex ?? 0)
//        
//    }
//    
    override func jwplayerHasSeeked(_ player: any JWPlayer) {
//        player.play()
        if player.getState() != .playing{
            print("Again Play")
            player.play()
        }
        print("Seeked")
    }
    
    override func jwplayer(_ player: any JWPlayer, didLoadPlaylistItem item: JWPlayerItem, at index: UInt) {
//        player.loadPlayerItemAt(index: 4)
//        player.play(relatedContent: 4)
        print("Item" , item)
    }
    
    override func jwplayerIsReady(_ player: JWPlayer) {
        super.jwplayerIsReady(player)
//        player.seek(to: 30)
//        player.play()
        print("IsReady")
    }

    override func jwplayer(_ player: JWPlayer, failedWithSetupError code: UInt, message: String) {
        super.jwplayer(player, failedWithSetupError: code, message: message)
        print("Setup Error: \(code) - \(message)")
    }

    override func jwplayer(_ player: JWPlayer, failedWithError code: UInt, message: String) {
        super.jwplayer(player, failedWithError: code, message: message)
        // if no internet then add network observer
        print("Error: \(code) - \(message)")
    }

    override func jwplayer(_ player: JWPlayer, encounteredWarning code: UInt, message: String) {
        super.jwplayer(player, encounteredWarning: code, message: message)
        print("Warning: \(code) - \(message)")
    }

    override func jwplayer(_ player: JWPlayer, encounteredAdError code: UInt, message: String) {
        super.jwplayer(player, encounteredAdError: code, message: message)
        print("Ad Error: \(code) - \(message)")
    }

    override func jwplayer(_ player: JWPlayer, encounteredAdWarning code: UInt, message: String) {
        super.jwplayer(player, encounteredAdWarning: code, message: message)
        print("Ad Warning: \(code) - \(message)")
    }

    override func jwplayer(_ player: JWPlayer, isBufferingWithReason reason: JWBufferReason) {
        super.jwplayer(player, isBufferingWithReason: reason)
//        player.play()
        print("Buffering Reason:", reason)
    }
    
    override func jwplayer(_ player: JWPlayer, didPauseWithReason reason: JWPauseReason) {
        super.jwplayer(player, didPauseWithReason: reason)
        // Implement custom behavior
    }
}

// MARK: - Full Screen Handling

extension PlayerVC {
   
    func playerViewControllerWillGoFullScreen(_ controller: JWPlayerViewController) -> JWFullScreenViewController? {
//        controller.shouldEnterFullScreen = false
        self.setDeviceOrientation(orientation: .portrait)
        print("playerViewControllerWillGoFullScreen")
        return nil
    }

    func playerViewControllerDidGoFullScreen(_ controller: JWPlayerViewController) {
        print("playerViewControllerDidGoFullScreen")

        return
    }

    func playerViewControllerWillDismissFullScreen(_ controller: JWPlayerViewController) {
        print("playerViewControllerWillDismissFullScreen")

//        self.setDeviceOrientation(orientation: .portrait)
//        Timer.scheduledTimer(withTimeInterval: 0.4, repeats: false) { _ in
//            controller.dismissFullScreen(animated: false) {
//                self.dismissTapped?()
//            }
//        }
        self.rotateToPotraitScapeDevice()
//        self.dismiss
//                self.setDeviceOrientation(orientation: .portrait)
//        Timer.scheduledTimer(withTimeInterval: 1, repeats: false) { _ in
//            controller.dismiss(animated: false) {
//        }
//            self.setDeviceOrientation(orientation: .portrait)
//        }
    }

    func playerViewControllerDidDismissFullScreen(_ controller: JWPlayerViewController) {
        print("playerViewControllerDidDismissFullScreen")

            self.dismissTapped?()
        Timer.scheduledTimer(withTimeInterval: 0.5, repeats: false) { _ in
            self.player.stop()
            controller.dismiss(animated: true)
        }
//        self.navigationController?.popViewController(animated: true)
    }
//    func playerViewControllerWillGoFullScreen(_ controller: JWPlayerViewController) -> JWFullScreenViewController? {
//        print("playerViewControllerWillGoFullScreen")
//        return nil
//    }
//
//    func playerViewControllerDidGoFullScreen(_ controller: JWPlayerViewController) {
//        print("playerViewControllerDidGoFullScreen")
//    }
//
//    func playerViewControllerWillDismissFullScreen(_ controller: JWPlayerViewController) {
//        print("playerViewControllerWillDismissFullScreen")
//        self.player.stop()
//        self.dismissTapped?()
//        self.setDeviceOrientation(orientation: .portrait)
//    }
//
//    func playerViewControllerDidDismissFullScreen(_ controller: JWPlayerViewController) {
//        print("playerViewControllerDidDismissFullScreen")
//        Timer.scheduledTimer(withTimeInterval: 0.3, repeats: false) { _ in
//            self.navigationController?.popViewController(animated: true)
//        }
//    }
}

// MARK: - JWPlayerViewController Delegate Functions

extension PlayerVC {
    
    func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, controlBarVisibilityChanged isVisible: Bool, frame: CGRect) {
//        backButton.isHidden = !isVisible
    }

    func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, sizeChangedFrom oldSize: CGSize, to newSize: CGSize) {
        // Handle size change if necessary
    }

    func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, screenTappedAt position: CGPoint) {
        // Handle screen tap if necessary
    }

    func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, relatedMenuOpenedWithItems items: [JWPlayerKit.JWPlayerItem], withMethod method: JWPlayerKit.JWRelatedInteraction) {
        print("Related items:", items)
    }

    func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, relatedMenuClosedWithMethod method: JWRelatedInteraction) {
        print("Related menu closed")
    }
    
    func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, relatedItemBeganPlaying item: JWPlayerKit.JWPlayerItem, atIndex index: Int, withMethod method: JWPlayerKit.JWRelatedMethod) {
        print("Item ", item)
    }
}

// MARK: - Orientation Handling

extension UIViewController {
    
    func setDeviceOrientation(orientation: UIInterfaceOrientationMask) {
        if #available(iOS 16.0, *) {
            let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene
            windowScene?.requestGeometryUpdate(.iOS(interfaceOrientations: orientation))
        } else {
            UIDevice.current.setValue(orientation.toUIInterfaceOrientation.rawValue, forKey: "orientation")
        }
    }
}

extension UIInterfaceOrientationMask {
    var toUIInterfaceOrientation: UIInterfaceOrientation {
        switch self {
        case .portrait:
            return .portrait
        case .portraitUpsideDown:
            return .portraitUpsideDown
        case .landscapeRight:
            return .landscapeRight
        case .landscapeLeft:
            return .landscapeLeft
        default:
            return .unknown
        }
    }
}