import Foundation

public struct CaptureFrameMetaData: Equatable {
    
    public enum CapturePermissionState {
        case requesting
        case error
        case notPermitted
        case permitted
    }
    
    public let deltaTime: TimeInterval
    public let captureRecordingState: CaptureRecordingState
    public let audioPermissionsState: CaptureCoordinator.AudioPermissionsState
    public let videoPermissionsState: CaptureCoordinator.VideoPermissionsState
    
    public var debugDescription: String {
        let formattedDeltaTime = String(format: "%.5f", deltaTime)
        return """
        Frame MetaData:
        Delta Time: \(formattedDeltaTime)s"
        Recording State: \(captureRecordingState)"
        """
    }
    
    public init(
        deltaTime: TimeInterval = .zero,
        captureRecordingState: CaptureRecordingState = .needsSetup,
        audioPermissionsState: CaptureCoordinator.AudioPermissionsState = .requesting,
        videoPermissionsState: CaptureCoordinator.VideoPermissionsState = .requesting) {
            
        self.deltaTime = deltaTime
        self.captureRecordingState = captureRecordingState
        self.audioPermissionsState = audioPermissionsState
        self.videoPermissionsState = videoPermissionsState
    }
    
    public var combinedPermissionState: CapturePermissionState {
        var foundError = false
        var foundLackOfAccess = false
        var isStillRequestingAccess = false
        
        switch audioPermissionsState {
        case .requesting:
            isStillRequestingAccess = true
        case .error:
            foundError = true
        case .notPermitted:
            foundLackOfAccess = true
        case .permitted:
            break
        }
        
        switch videoPermissionsState {
        case .requesting:
            isStillRequestingAccess = true
        case .error:
            foundError = true
        case .notPermitted:
            foundLackOfAccess = true
        case .permitted:
            break
        }
        
        if foundError {
            return .error
        } else if foundLackOfAccess {
            return .notPermitted
        } else if isStillRequestingAccess {
            return .requesting
        } else {
            return .permitted
        }
    }
}

public enum CaptureOption: Equatable {
    case shouldUseFlash
    case shouldComposeOnCapture
}

public class CaptureCoordinator: ObservableObject {
    
    enum CaptureCompositionState {
        case notComposing
        case composing
    }
    
    public enum VideoPermissionsState: Equatable {
        case requesting
        case notPermitted
        case permitted
        case error
    }
    
    public enum AudioPermissionsState: Equatable {
        case requesting
        case notPermitted
        case permitted
        case error
    }
    
    private let syncQueue = DispatchQueue(
        label: "Coordinator Sync Queue",
        qos: .userInitiated,
        attributes: [],
        autoreleaseFrequency: .workItem)
    
    @Published public var zoom: CGFloat = 1.0
    @Published public private(set) var recordingFPS: Float = 60.0
    
    // Originals
    @Published private(set) var capturedVideoURL: URL?
    @Published private(set) var capturedPhotoURL: URL?
    @Published private(set) var capturedAudioURL: URL?
    
    // Composed
    @Published private(set) var composedVideoWithAudio: URL?
    
    @Published public var captureOptions: Set<CaptureOption> = []
    @Published private var videoPermissionsState: VideoPermissionsState = .requesting
    @Published private var audioPermissionsState: AudioPermissionsState = .requesting
    
    public var frameUpdateAction: (CaptureFrameMetaData, CaptureViewSignalToEndAction) -> Void = { _, _ in }
    
    private let videoComposer = VideoCompositionUtility()
    var previewCoordinator = PreviewMetalViewCoordinator()
    var videoCaptureCoordinator = VideoCaptureCoordinator()
    var audioCaptureCoordinator = AudioCaptureCoordinator()
    var hasTriggeredEndRecording = false
    var recentFramerateHistory: [Float] = []
    
    private var captureCompositionState: CaptureCompositionState = .notComposing
    
#if targetEnvironment(simulator)
    
    public init() { }
    
    public func resetAfterActiveSession() { }
    
    public func flipCamera() { }
    
    public func capturePhoto() { }
    
    public func enabledFlashIfNeeded() { }
    
    public func startVideoRecording() { }
    
    public func endVideoRecording() {  }
    
#else
    
    public init() {
        previewCoordinator.delegate = self
        previewCoordinator.audioCaptureCoordinator = audioCaptureCoordinator
        previewCoordinator.videoCaptureCoordinator = videoCaptureCoordinator
        
        // Video Capture Coordinator
        videoCaptureCoordinator.previewCoordinator = previewCoordinator
        videoCaptureCoordinator.delegate = self
        videoCaptureCoordinator.configure()
        
        // Audio Capture
        audioCaptureCoordinator.delegate = self
        audioCaptureCoordinator.configure()
    }
    
    public func resetAfterActiveSession() {
        previewCoordinator.resetAfterActiveSession()
    }
    
    public func flipCamera() {
        videoCaptureCoordinator.flipCamera()
    }
    
    public func capturePhoto() {
        guard case .readyToRecord = previewCoordinator.recordingState else { return }
        if shouldUseFlash {
            Task {
                videoCaptureCoordinator.toggleFlash(true)
                try await Task.sleep(for: .seconds(0.5))
                videoCaptureCoordinator.toggleFlash(false)
                previewCoordinator.capturePhoto()
                try await Task.sleep(for: .seconds(0.05))
                videoCaptureCoordinator.toggleFlash(true)
                try await Task.sleep(for: .seconds(0.1))
                videoCaptureCoordinator.toggleFlash(false)
                audioCaptureCoordinator.resetAudioSessionForPlayback()
            }
        } else {
            previewCoordinator.capturePhoto()
            audioCaptureCoordinator.resetAudioSessionForPlayback()
        }
    }
    
    public func enabledFlashIfNeeded() {
        guard shouldUseFlash else { return }
        videoCaptureCoordinator.toggleFlash(true)
    }
    
    public func startVideoRecording() {
        guard case .readyToRecord = previewCoordinator.recordingState else { return }
        previewCoordinator.startRecording()
    }
    
    public func endVideoRecording() {
        guard case .isRecording = previewCoordinator.recordingState else { return }
        previewCoordinator.endRecording()
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
            self?.disableFlashIfNeeded()
        }
    }
    
#endif
    
    func composeVideoAndAudioIfAvailable() {
        guard
            captureCompositionState == .notComposing,
            let _ = capturedVideoURL,
            let _ = capturedAudioURL
        else { return }
        captureCompositionState = .composing
        composeVideoAndAudio()
    }
}

extension CaptureCoordinator: VideoCaptureCoordinatorDelegate {
    func didUpdateVideoConfiguration(_ result: VideoCaptureCoordinator.SessionSetupResult) {
        DispatchQueue.main.async { [weak self] in
            switch result {
            case .configurationFailed:
                self?.videoPermissionsState = .error
            case .notAuthorized:
                self?.videoPermissionsState = .notPermitted
            case .notStarted:
                self?.videoPermissionsState = .requesting
            case .success:
                self?.videoPermissionsState = .permitted
            }
        }
    }
}

extension CaptureCoordinator: AudioCaptureCoordinatorDelegate {
    func didUpdateAudioConfiguration(_ result: AudioCaptureCoordinator.SessionSetupResult) {
        DispatchQueue.main.async { [weak self] in
            switch result {
            case .configurationFailed:
                self?.audioPermissionsState = .error
            case .notAuthorized:
                self?.audioPermissionsState = .notPermitted
            case .notStarted:
                self?.audioPermissionsState = .requesting
            case .success:
                self?.audioPermissionsState = .permitted
            }
        }
    }
    
    func didFinishRecordingAudio(_ output: URL?) {
        setAudioOutput(output)
    }
}

extension CaptureCoordinator: PreviewMetalViewCoordinatorDelegate {
    func didUpdateVideoRecordingFrame(_ deltaTime: TimeInterval, recordingState: CaptureRecordingState) {
        
        DispatchQueue.main.async { [weak self] in
            guard let self else { return }
            frameUpdateAction(
                .init(
                    deltaTime: deltaTime,
                    captureRecordingState: recordingState,
                    audioPermissionsState: audioPermissionsState,
                    videoPermissionsState: videoPermissionsState),
                endVideoRecording
            )
        }
    }
    
    func setFrameRateUpdate(_ fps: Float) {
        DispatchQueue.main.async { [weak self] in
            guard 
                let self,
                case .isRecording = self.previewCoordinator.recordingState,
                fps != .zero
            else { return }
            
            self.recentFramerateHistory.append(fps)
            
            if self.recentFramerateHistory.count > 60 {
                self.recentFramerateHistory.removeFirst()
            }
            
            let fps = self.recentFramerateHistory.reduce(.zero, +) / Float(self.recentFramerateHistory.count)
            self.recordingFPS = fps
        }
    }
    
    func clearAllOutputURLs() {
        recentFramerateHistory = []
        capturedVideoURL = nil
        capturedPhotoURL = nil
        capturedAudioURL = nil
        composedVideoWithAudio = nil
    }
    
    func setVideoOutput(_ url: URL?) {
        capturedVideoURL = url
    }
    
    func setAudioOutput(_ url: URL?) {
        capturedAudioURL = url
    }
    
    func setImageOutput(_ url: URL?) {
        capturedPhotoURL = url
    }
}

private extension CaptureCoordinator {
    var shouldUseFlash: Bool {
        return captureOptions.contains(.shouldUseFlash)
    }
    
    func triggerFlashAfterDelay(_ toggleValue: Bool, _ delay: TimeInterval, completion: @escaping () -> Void) {
        DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
            self?.videoCaptureCoordinator.toggleFlash(toggleValue)
            completion()
        }
    }
    
    func disableFlashIfNeeded() {
        guard shouldUseFlash else { return }
        videoCaptureCoordinator.toggleFlash(false)
    }
    
    func composeVideoAndAudio() {
        DispatchQueue.main.async { [weak self] in
            guard
                let self,
                let noAudioVideoURL = self.capturedVideoURL,
                let audioURL = self.capturedAudioURL,
                let randomOutputURL = Adamantium.createRandomFileURLInDocuments("mp4")
            else { return }
            
            Task {
                await self.videoComposer.mergeVideoAndAudio(
                    videoURL: noAudioVideoURL,
                    audioURL: audioURL,
                    outputURL: randomOutputURL) { result in
                        switch result {
                        case .success(let url):
                            DispatchQueue.main.async { [weak self] in
                                self?.captureCompositionState = .notComposing
                                self?.composedVideoWithAudio = url
                            }
                        case .failure(let error):
                            print(error)
                        }
                    }
            }
        }
    }
}