//
//  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)?
    
    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()
        self.rotateToLandsScapeDevice()
        self.delegate = self
        player.configurePlayer(with: config)

//        NotificationCenter.default.addObserver(self, selector: #selector(applicationDidBecomeActive), name: UIApplication.willEnterForegroundNotification, object: nil)
    }
    
    
    @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)
            }
        }
    }
    
//    @objc func backButtonTapped() {
//        setDeviceOrientation(orientation: .portrait)
//    }
    
    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()
    }

    override func jwplayerIsReady(_ player: JWPlayer) {
        super.jwplayerIsReady(player)
        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)
        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
        }
    }
}