// GuruMaxRewardedAd.swift
// Implementation for MAX rewarded ads
// Corresponds to GuruMaxRewardedAd.kt in Android implementation

import Foundation
import UIKit
import AppLovinSDK

public class GuruMaxRewardedAd: GuruRewardedAd, MARewardedAdDelegate, MAAdRevenueDelegate {
    
    private let viewController: UIViewController
    private let adConfig: AdConfig
    private var rewardedAd: MARewardedAd?
    private var isFirstLoad = true
    
    public init(viewController: UIViewController, adConfig: AdConfig) {
        self.viewController = viewController
        self.adConfig = adConfig
        super.init(engineId: adConfig.engineId, adUnitId: adConfig.adUnitId, adPlatform: AdPlatform.max)
    }
    
    public override func load() -> Bool {
        logInfo("request load")
        destroy()
        
        rewardedAd = MARewardedAd.shared(withAdUnitIdentifier: adConfig.adUnitId)
        rewardedAd?.delegate = self
        rewardedAd?.revenueDelegate = self
        
        // Set UID2 token if available
        if let uid2Token = AdsHelper.getUid2Token() {
            rewardedAd?.setExtraParameterForKey("uid2_token", value: uid2Token)
        }
        rewardedAd?.setExtraParameterForKey("disable_auto_retries", value: self.adConfig.requireDisableAutoRetries ? "true":"false")
        
        if let amazonSlotId = adConfig.adAmazonSlotId, !amazonSlotId.isEmpty, isFirstLoad {
            isFirstLoad = false
            
            // In a real implementation, you would load Amazon ads here
            logWarn("Would load Amazon rewarded ad with slot ID: \(amazonSlotId)")
            
            // Simulate direct load for now
            rewardedAd?.load()
        } else {
            rewardedAd?.load()
        }
        
        return true
    }
    
    public override func show(_ request: RewardedShowRequest? = nil) -> Bool {
        logInfo("request show")
        guard let ad = rewardedAd, ad.isReady else {
            logDebug("Show result: false - ad not ready")
            return false
        }
        
        ad.show(forPlacement: request?.placement)
        logDebug("Show result: true")
        return true
    }
    
    public override func destroy()  -> Bool {
        rewardedAd?.delegate = nil
        rewardedAd?.revenueDelegate = nil
        rewardedAd = nil
        return true
    }
    
    // MARK: - MARewardedAdDelegate methods
    
    public func didLoad(_ ad: MAAd) {
        logInfo("loaded")
        listener?.onAdLoaded(ad: MaxFusionAd(engineId: engineId, adType: AdType.Rewarded, ad: ad))
    }
    
    
    public func didFail(toDisplay ad: MAAd, withError error: MAError) {
        logError("displayed failed, \(error.code) - \(error.message)")
        listener?.onAdDisplayFailed(ad: MaxFusionAd(engineId: engineId, adType: AdType.Rewarded, ad: ad), error: MaxFusionError(error))
    }
    
    public func didFailToLoadAd(forAdUnitIdentifier adUnitIdentifier: String, withError error: MAError) {
        logError("load failed, \(error.code) - \(error.message)")
        let loadFailedInfo = LoadFailedInfo(
            engineId: engineId,
            adPlatform: AdPlatform.max,
            adType: AdType.Rewarded,
            adUnitId: adUnitIdentifier,
            error: MaxFusionError(error)
        )
        listener?.onAdLoadFailed(loadFailedInfo: loadFailedInfo)
    }
    
    public func didDisplay(_ ad: MAAd) {
        logInfo("displayed")
        listener?.onAdDisplayed(ad: MaxFusionAd(engineId: engineId, adType: AdType.Rewarded, ad: ad))
    }
    
    public func didHide(_ ad: MAAd) {
        listener?.onAdHidden(ad: MaxFusionAd(engineId: engineId, adType: AdType.Rewarded, ad: ad))
    }
    
    public func didClick(_ ad: MAAd) {
        listener?.onAdClicked(ad: MaxFusionAd(engineId: engineId, adType: AdType.Rewarded, ad: ad))
    }
    
    public func didStartRewardedVideo(for ad: MAAd) {
        // Additional callback if needed
    }
    
    public func didCompleteRewardedVideo(for ad: MAAd) {
        // Additional callback if needed
    }
    
    public func didRewardUser(for ad: MAAd, with reward: MAReward) {
        logInfo("reward user")
        listener?.onUserRewarded(
            ad: MaxFusionAd(engineId: engineId, adType: AdType.Rewarded, ad: ad),
            reward: MaxFusionReward(reward)
        )
    }
    
    // MARK: - MAAdRevenueDelegate methods
    
    public func didPayRevenue(for ad: MAAd) {
        logInfo("revenue paid")
        listener?.onAdRevenuePaid(ad: MaxFusionAd(engineId: engineId, adType: AdType.Rewarded, ad: ad))
    }
}