import Foundation
import CoreHaptics

@objc(HapticEngine)
class HapticEngine: NSObject {
    // MARK: - Private API
    private static let shared = HapticEngine()
    
    private class Key {
        static let defaultEngine: NSString = "default_engine"
    }
    
    private var engines: [NSString: CHHapticEngine] = [:]
    private var players: [HapticPattern: CHHapticPatternPlayer] = [:]
    
    // store the last player in memory to allow cancellation
    private var hapticPatternPlayer: CHHapticPatternPlayer? = nil

    // MARK: - Public API
    /**
     * Get JSON representation of HapticDeviceCapability. Currently supported keys:
     * - supportsHaptics
     * - supportsAudio
     */
    @objc(getDeviceCapabilities:reject:)
    func getDeviceCapabilities(resolve: RCTPromiseResolveBlock,
                               reject: RCTPromiseRejectBlock) {
        let hapticCapabilities = CoreHaptics.CHHapticEngine.capabilitiesForHardware()
        let capabilities = HapticDeviceCapability(hapticCapabilities)
        let capabilitiesJSON = capabilities.toJSON()
        resolve(capabilitiesJSON)
    }
    
    /**
     * Starts the HapticEngine. Uses the default HapticEngine instance.
     * If needed, this also creates the CHHapticEngine underlying instance. Required step before playing any HapticPatternPlayer, but does not initiate a HapticPatternPlayer session itself. Use -makePlayer and/or -startPlayerAtTime.
     * There is no way to get a reference to the HapticEngine itself in JS, so we hold onto it as a singleton value.
     * @returns Resolving Promise with boolean indicating if it was possible to create/start the engine
     */
    @objc(start:reject:)
    func start(resolve: @escaping RCTPromiseResolveBlock,
               reject: @escaping  RCTPromiseRejectBlock) {
        // Check if device supports haptics first
        guard CHHapticEngine.capabilitiesForHardware().supportsHaptics else {
            reject("HAPTICS_NOT_SUPPORTED", "Device does not support haptics", nil)
            return
        }
        
        var engine: CHHapticEngine
        
        if let existingEngine = HapticEngine.shared.engines[Key.defaultEngine] {
            engine = existingEngine
        }
        
        else {
            do {
                let newEngine = try CHHapticEngine()
                
                // Add reset and stopped handlers for better error handling
                newEngine.resetHandler = {
                    print("Haptic engine reset")
                }
                
                newEngine.stoppedHandler = { reason in
                    print("Haptic engine stopped: \(reason.rawValue)")
                }
                
                HapticEngine.shared.engines[Key.defaultEngine] = newEngine
                engine = newEngine
            } catch let e {
                reject("Unable to create engine", e.localizedDescription, e)
                return
            }
        }
        
        engine.start { (err) in
            if let err = err {
                reject("Unable to start engine", err.localizedDescription, err)
            } else {
                resolve(true)
            }
        }
    }
    
    /**
     * Creates a new HapticPatternPlayer with given HapticPattern. Will create an engine before making a player if does not exist, although you will still have to use -start to start the engine. This player is stored in the HapticEngine singleton. Once the engine is started, this player may also be started at a given time using -startPlayerAtTime. The correct player is chosen by matching the HapticPattern given here (a simple equality check using parameterID and value). A HapticPattern is a type which consists of:
     * - parameterID (HapticEventParameterID, a string-based type with only rawValue)
     * - value (number)
     * @param pattern Pattern to use when creating a new player
     * @returns Resolving Promise with boolean indicating if it was possible to create the player
     */
    @objc(makePlayer:resolve:reject:)
    func makePlayer(pattern: HapticPattern,
                    resolve: RCTPromiseResolveBlock,
                    reject: RCTPromiseRejectBlock) {
        var engine: CHHapticEngine
        
        if let existingEngine = HapticEngine.shared.engines[Key.defaultEngine] {
            engine = existingEngine
        }
        
        else {
            do {
                let newEngine = try CHHapticEngine()
                HapticEngine.shared.engines[Key.defaultEngine] = newEngine
                engine = newEngine
            } catch let e {
                reject("Unable to create engine", e.localizedDescription, e)
                return
            }
        }
        
        do {
            let patternObject = HapticPatternObject(pattern)
            guard let hapticPattern = patternObject.toHapticPattern() else {
                reject("Unable to create pattern", "Unknown error", nil)
                return
            }
            
            let patternPlayer = try engine.makePlayer(with: hapticPattern)
            players[pattern] = patternPlayer

            resolve(true)
        } catch let e {
            reject("Unable to make player", e.localizedDescription, nil)
        }
    }

    /**
     * Starts an existing HapticPatternPlayer at a given time. If the player does not exist, the HapticEngine will attempt to create it using -makePlayer before resolving. If the engine does not exist, the HapticEngine will attempt to also create and start that before resolving. If the engine does exist, we assume it has already been started.
     * @param startTime number (TimeInterval) offset to begin the pattern
     * @returns Resolving Promise with boolean indicating if it was possible to start the player (and create it if needed)
     */
    @objc(startPlayerAtTime:startTime:resolve:reject:)
    func startPlayerAtTime(pattern: HapticPattern,
                           startTime: NSNumber,
                           resolve: RCTPromiseResolveBlock,
                           reject: RCTPromiseRejectBlock) {
        var engine: CHHapticEngine
        
        if let hapticPatternPlayer {
            do {
                try hapticPatternPlayer.stop(atTime: CHHapticTimeImmediate)
            } catch let e {
                reject("Unable to stop the active player before starting the new haptic pattern", e.localizedDescription, e)
                return
            }
        }

        if let existingEngine = HapticEngine.shared.engines[Key.defaultEngine] {
            engine = existingEngine
        }
        
        else {
            do {
                let newEngine = try CHHapticEngine()
                HapticEngine.shared.engines[Key.defaultEngine] = newEngine
                engine = newEngine
            } catch let e {
                reject("Unable to create engine", e.localizedDescription, e)
                return
            }
            
            do {
                try engine.start()
            } catch let e {
                reject("Unable to start engine", e.localizedDescription, e)
            }
        }
        
        if let existingPatternPlayer = HapticEngine.shared.players[pattern] {
            hapticPatternPlayer = existingPatternPlayer
        }
        
        else {
            do {
                let patternObject = HapticPatternObject(pattern)
                guard let hapticPattern = patternObject.toHapticPattern() else {
                    reject("Unable to create pattern", "Unknown error", nil)
                    return
                }
                
                let patternPlayer = try engine.makePlayer(with: hapticPattern)
                players[pattern] = patternPlayer
                hapticPatternPlayer = patternPlayer
            } catch let e {
                reject("Unable to make player", e.localizedDescription, nil)
                return
            }
        }
        
        do {
            // Use CHHapticTimeImmediate for immediate playback when startTime is 0 or negative
            // This fixes the timing validation error in Release builds
            let startTimeValue = startTime.doubleValue
            let playbackTime = startTimeValue <= 0 ? CHHapticTimeImmediate : TimeInterval(startTimeValue)
            try hapticPatternPlayer?.start(atTime: playbackTime)
            
            resolve(true)
        } catch let e {
            reject("Unable to start player", e.localizedDescription, nil)
        }
    }
    
    /**
     * Stops the HapticEngine immediately. Uses the default engine.
     * @returns Resolving Promise with boolean indicating if it was possible to stop
     */
    @objc(stop:reject:)
    func stop(resolve: @escaping RCTPromiseResolveBlock,
              reject: @escaping RCTPromiseRejectBlock) {
        // First, stop any active player immediately
        if let activePlayer = hapticPatternPlayer {
            do {
                try activePlayer.stop(atTime: CHHapticTimeImmediate)
            } catch {
                print("Warning: Could not stop active haptic player: \(error.localizedDescription)")
            }
            hapticPatternPlayer = nil
        }
        
        guard let existingEngine = HapticEngine.shared.engines[Key.defaultEngine] else {
            // If no engine exists, consider it already stopped
            resolve(true)
            return
        }
        
        existingEngine.stop { [weak self] (err) in
            if let err = err {
                reject("Unable to stop engine", err.localizedDescription, nil)
            } else {
                self?.hapticPatternPlayer = nil
                resolve(true)
            }
        }
    }
}
