//
//  LunchViewController.swift
//  MusicPlayer
//
//  Created by Mr.Zhou on 2024/3/27.
//

import UIKit
import GoogleMobileAds
///启动页
class MP_LunchViewController: UIViewController, GADFullScreenContentDelegate {
    @IBOutlet weak var progressView: MP_Lunch_ProgressView!{
        didSet{
            progressView.layer.masksToBounds = true
        }
    }
    //帧计时器
    private var timer:CADisplayLink!
    //最大计时值
    private lazy var maxTimes:TimeInterval = 10
    //当前计时值
    private lazy var currentTimes:TimeInterval = 0
    //计时器结束事件
    private var completionBlock:(() -> Void)?
    //是否执行过A/B面检测
    private var isBeen:Bool = false
    //广告事件传递闭包
    private var adShowBlock:(() -> Void)?
    //切换事件传递闭包
    private var switchBlock:(() -> Void)?
    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .init(hex: "#000000")
        timer = CADisplayLink(target: self, selector: #selector(timerActionClick(_ :)))
        //一秒执行多少次
        timer.preferredFramesPerSecond = 40
        //开辟线程
        timer.add(to: RunLoop.current, forMode: .common)
        //启动计时器
        timer.isPaused = false
        //拉取开屏广告
        MP_AdMobManager.shared.showOpenAdIfAvailable(.ICE) { [weak self] ad in
            guard let self = self else {return}
            //将广告事件传递闭包赋值
            adShowBlock = {
                //修改插页总开关状态
                MP_AdMobManager.shared.setInterstitialSwitch(true)
                //覆盖并实现代理
                ad.fullScreenContentDelegate = self
                ad.present(fromRootViewController: self)
            }
        }
        switchBlock = {
            [weak self] in
            guard let self = self else {return}
            guard MP_NetWorkManager.shared.netWorkStatu != .reachable else {
                if completionBlock != nil {
                    completionBlock!()
                }else {
                    //完成闭包没有配置完成，直接前往A面
                    print("ALog")
                    //打开A面
                    DispatchQueue.main.async {
                        [weak self] in
                        guard let self = self else {return}
                        //停止计时器
                        timer.isPaused = true
                        //加载完毕，判断并跳转
                        accessAppdelegate.switch_aSide()
                    }
                }
                return
            }
            //进度条加载结束，执行完成闭包
            if completionBlock != nil {
                completionBlock!()
            }else {
                //完成闭包没有配置完成，直接前往A面
                print("ALog")
                //打开A面
                DispatchQueue.main.async {
                    [weak self] in
                    guard let self = self else {return}
                    //停止计时器
                    timer.isPaused = true
                    //加载完毕，判断并跳转
                    accessAppdelegate.switch_aSide()
                }
            }
        }
    }
    deinit {
        timer.isPaused = true
        //销毁计时器
        timer.invalidate()
        timer = nil
        NotificationCenter.default.removeObserver(self)
    }
    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
            // 请求跟踪授权
            requestTrackingAuthorization { idfa in
            }
        }
    }
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        MP_AnalyticsManager.shared.launch_pvAction()
    }
    
    //计时器执行事件
    @objc fileprivate func timerActionClick(_ link:CADisplayLink) {
        if maxTimes > currentTimes {
            //未加载完
            currentTimes += 0.025
            let value = (currentTimes/maxTimes).isNaN ? 0:(currentTimes/maxTimes)
            DispatchQueue.main.async {
                [weak self] in
                guard let self = self else {return}
                //设置进度条
                progressView.setProgress(value)
            }
            //执行A/B面检测
            if isBeen == false && currentTimes > 2 {
                //修改值避免一直检测
                isBeen = true
                switchAOrBAction()
            }
        }else {
            //停止计时器
            timer.isPaused = true
            //判断是否具备广告
            if adShowBlock != nil {
                adShowBlock!()
            }else {
                switchBlock!()
            }
        }
    }
    //a/b面开关判断
    private func switchAOrBAction() {
        //首先检测之前是否进入过B面
        guard UserDefaults.standard.bool(forKey: "MP_Into_B") != true else {
            //获取B面首页数据
            MPPositive_BrowseLoadViewModel.shared.reloadBrowseLists()
            //进入过B面
            self.completionBlock = {
                //允许进入b面
                print("BLog")
                //保存进入B面的记录，下次加载直接进入B面
                UserDefaults.standard.set(true, forKey: "MP_Into_B")
                DispatchQueue.main.async {
                    [weak self] in
                    guard let self = self else {return}
                    //停止计时器
                    timer.isPaused = true
                    //加载完毕，判断并跳转
                    accessAppdelegate.switch_positive()
                }
            }
            return
        }
        MP_NetWorkManager.shared.performTaskNetWrokAvailable {
            [weak self] in
            guard let self = self else {return}
            //获取B面首页数据
            MPPositive_BrowseLoadViewModel.shared.reloadBrowseLists()
            //进行开关检测
            MP_AnalyticsManager.shared.getOpenStatus { [weak self] open in
                guard let self = self else {return}
                if open {
                    //开关检测为通过，在检测IP地址
                    //根据ip值确定进入那个页面
                    MP_NetWorkManager.shared.requestIPInfo { statu in
                        if statu == true {
                            //允许进入b面
                            print("BLog")
                            //保存进入B面的记录，下次加载直接进入B面
                            UserDefaults.standard.set(true, forKey: "MP_Into_B")
                            //判断当前时间节点是否已经超时
                            if self.maxTimes > self.currentTimes {
                                //未超时，完成包处理
                                self.completionBlock = {
                                    DispatchQueue.main.async {
                                        [weak self] in
                                        guard let self = self else {return}
                                        
                                        //停止计时器
                                        timer.isPaused = true
                                        //加载完毕，判断并跳转
                                        accessAppdelegate.switch_positive()
                                    }
                                }
                            }else {
                                DispatchQueue.main.async {
                                    [weak self] in
                                    guard let self = self else {return}
                                    
                                    //停止计时器
                                    timer.isPaused = true
                                    //加载完毕，判断并跳转
                                    accessAppdelegate.switch_positive()
                                }
                            }
                        }else {
                            print("ALog")
                            //打开A面
                            if self.maxTimes > self.currentTimes {
                                self.completionBlock = {
                                    DispatchQueue.main.async {
                                        [weak self] in
                                        guard let self = self else {return}
                                        //停止计时器
                                        timer.isPaused = true
                                        //加载完毕，判断并跳转
                                        accessAppdelegate.switch_aSide()
                                    }
                                }
                            }else {
                                DispatchQueue.main.async {
                                    [weak self] in
                                    guard let self = self else {return}
                                    //停止计时器
                                    timer.isPaused = true
                                    //加载完毕，判断并跳转
                                    accessAppdelegate.switch_aSide()
                                }
                            }
                        }
                    }
                }else {
                    print("ALog")
                    //打开A面
                    if self.maxTimes > self.currentTimes {
                        self.completionBlock = {
                            DispatchQueue.main.async {
                                [weak self] in
                                guard let self = self else {return}
                                //停止计时器
                                timer.isPaused = true
                                //加载完毕，判断并跳转
                                accessAppdelegate.switch_aSide()
                            }
                        }
                    }else {
                        DispatchQueue.main.async {
                            [weak self] in
                            guard let self = self else {return}
                            //停止计时器
                            timer.isPaused = true
                            //加载完毕，判断并跳转
                            accessAppdelegate.switch_aSide()
                        }
                    }
                }
            }
        }
    }
    //MARK: - 覆盖型广告代理 GADFullScreenContentDelegate
    //覆盖型广告已经消失
    func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
        //当前启动页，展示广告一定是开屏广告
        if switchBlock != nil {
            switchBlock!()
        }
        if MP_AdMobManager.shared.completeOpenAdBlock != nil {
            MP_AdMobManager.shared.completeOpenAdBlock!()
        }
    }
    //覆盖型广告加载出错
    func ad(_ ad: GADFullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
        //当前启动页，展示广告一定是开屏广告
        if switchBlock != nil {
            switchBlock!()
        }
        if MP_AdMobManager.shared.completeOpenAdBlock != nil {
            MP_AdMobManager.shared.completeOpenAdBlock!()
        }
    }
}