import AtomicXCore
import Combine

// 主播A的视图控制器
class AnchorAViewController {
    private let liveId = "主播A的房间ID"
    private var cancellables: Set<AnyCancellable> = []
    private lazy var coHostStore: CoHostStore = {
        return CoHostStore.create(liveID: self.liveId)
    }()

    // 用户点击“连线”按钮，并选择了主播B
    func inviteHostB(targetHostLiveId: String) {
        let layout: CoHostLayoutTemplate = .hostDynamicGrid // 选择一个布局模板
        let timeout: TimeInterval = 30.0 // 邀请超时时间

        coHostStore.requestHostConnection(targetHost: targetHostLiveId,
                                          layoutTemplate: layout,
                                          timeout: timeout) { result in
            switch result {
            case .success():
                print("连线邀请已发送，等待对方处理...")
            case .failure(let error):
                print("邀请发送失败: \\(error.message)")
            }
        }
    }
}

// 在 AnchorAViewController 初始化时设置监听
func setupListeners() {
    coHostStore.coHostEventPublisher
        .sink { [weak self] event in
            switch event {
            case .onCoHostRequestAccepted(let invitee): //
                print("主播 \\(invitee.userName) 同意了你的连线邀请")
            case .onCoHostRequestRejected(let invitee): //
                print("主播 \\(invitee.userName) 拒绝了你的邀请")
            case .onCoHostRequestTimeout: //
                print("邀请超时，对方未回应")
            default:
                break
            }
        }
        .store(in: &cancellables)
}

import AtomicXCore
import Combine

// 主播B的视图控制器
class AnchorBViewController {
    // ... coHostStore 和 cancellables 初始化 ...

    // 在初始化时设置监听
    func setupListeners() {
        coHostStore.coHostEventPublisher
            .sink { [weak self] event in
                if case let .onCoHostRequestReceived(inviter, _) = event { //
                    print("收到主播 \\(inviter.userName) 的连线邀请")
                    // self?.showInvitationDialog(from: inviter)
                }
            }
            .store(in: &cancellables)
    }
}

// AnchorBViewController 的一部分
func acceptInvitation(fromHostLiveId: String) {
    coHostStore.acceptHostConnection(fromHostLiveID: fromHostLiveId, completion: nil) //
}

func rejectInvitation(fromHostLiveId: String) {
    coHostStore.rejectHostConnection(fromHostLiveID: fromHostLiveId, completion: nil) //
}

  
// AnchorAViewController 的一部分
private lazy var battleStore: BattleStore = BattleStore.create(liveID: self.liveId)

func startPK(with opponentUserId: String) {
    var config = BattleConfig(duration: 300) // PK持续5分钟
    battleStore.requestBattle(config: config, userIDList: [opponentUserId], timeout: 30.0, completion: nil)
}

// 在 AnchorAViewController 的 setupListeners 方法中添加
battleStore.battleEventPublisher
    .sink { [weak self] event in
        switch event {
        case .onBattleStarted: //
            print("PK 开始")
        case .onBattleEnded: //
            print("PK 结束")
        default:
            break
        }
    }
    .store(in: &cancellables)

// 在 AnchorBViewController 的 setupListeners 方法中添加
battleStore.battleEventPublisher
    .sink { [weak self] event in
        if case let .onBattleRequestReceived(battleId, inviter, _) = event {
            print("收到主播 \\(inviter.userName) 的PK挑战")
            // 弹出对话框，让主播B选择“接受”或“拒绝”
            // self?.showPKChallengeDialog(battleId: battleId)
        }
    }
    .store(in: &cancellables)

// AnchorBViewController 的一部分
// 用户点击“接受挑战”
func acceptPK(battleId: String) {
    battleStore.acceptBattle(battleID: battleId) { result in
        // ...
    }
}

// 用户点击“拒绝挑战”
func rejectPK(battleId: String) {
    battleStore.rejectBattle(battleID: battleId) { result in
        // ...
    }
}

// AnchorAViewController 的一部分

// 主播主动结束 PK
func stopPK(battleId: String) {
    // 调用 exitBattle 接口退出当前的 PK 对战
    battleStore.exitBattle(battleID: battleId) { result in
        switch result {
        case .success:
            print("PK 已结束")
            // 此时 UI 会收到 onBattleEnded 事件，请在事件回调中处理 UI 刷新
        case .failure(let error):
            print("结束 PK 失败: \\(error.message)")
        }
    }
}

// AnchorAViewController 的一部分

// 主播主动断开连线
func stopConnection() {
    // 调用 exitHostConnection 接口断开与其他主播的连接
    coHostStore.exitHostConnection { result in
        switch result {
        case .success:
            print("连线已断开，恢复单人直播")
            // 此时 UI 会收到 onCoHostUserLeft 事件
        case .failure(let error):
            print("断开连线失败: \\(error.message)")
        }
    }
}

// 在 setupListeners 方法中补充以下监听逻辑

func setupAdditionalListeners() {
    // 1. 监听 PK 结束事件
    battleStore.battleEventPublisher
        .sink { [weak self] event in
            if case .onBattleEnded(let battleInfo, let reason) = event {
                print("收到 PK 结束事件，原因: \\(reason)")
                // 在此处移除 PK 分数视图、进度条等 UI
                // self?.removeBattleUI()
            }
        }
        .store(in: &cancellables)

    // 2. 监听连线断开事件
    coHostStore.coHostEventPublisher
        .sink { [weak self] event in
            if case .onCoHostUserLeft(let userInfo) = event {
                print("主播 \\(userInfo.userName) 已离开连线")
                // 在此处移除对方的视频画面视图，恢复单人直播布局
                // self?.resetToSingleStreamLayout()
            }
        }
        .store(in: &cancellables)
}

import UIKit
import SnapKit

// 自定义的用户信息悬浮视图（前景）
class CustomSeatView: UIView {
   lazy var nameLabel: UILabel = {
        let label = UILabel()
        label.textColor = .white
        label.font = .systemFont(ofSize: 14)
        return label
    }()

    override init(frame: CGRect) {
        super.init(frame: frame)
        backgroundColor = UIColor.black.withAlphaComponent(0.5)
        addSubview(nameLabel)
        nameLabel.snp.makeConstraints { make in
            make.bottom.equalToSuperview().offset(-5)
            make.leading.equalToSuperview().offset(5)
        }
    }
}

import UIKit
import SnapKit

// 自定义的头像占位视图（背景）
class CustomAvatarView: UIView {
    lazy var avatarImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.tintColor = .gray
        return imageView
    }()

    override init(frame: CGRect) {
        super.init(frame: frame)
        backgroundColor = .clear
        layer.cornerRadius = 30
        addSubview(avatarImageView)
        avatarImageView.snp.makeConstraints { make in
            make.center.equalToSuperview()
            make.width.height.equalTo(60)
        }
    }
}

import AtomicXCore
import RTCRoomEngine

// 在您的视图控制器中，遵守 VideoViewDelegate 协议
class YourViewController: UIViewController, VideoViewDelegate {

    // ... 其他代码 ...
    func setupCustomView() {
      // 1. 设置 LiveCoreView 自定义视图代理
      coreView.videoViewDelegate = self
    }
    
    // 2. 完整实现协议方法，处理两种 viewLayer
    func createCoHostView(seatInfo: TUISeatFullInfo, viewLayer: ViewLayer) -> UIView? {
        guard let userId = seatInfo.userId, !userId.isEmpty else {
            return nil
        }
        if viewLayer == .foreground {
            let seatView = CustomSeatView()
            seatView.nameLabel.text = seatInfo.userName
            return seatView
        } else { // viewLayer == .background
            let avatarView = CustomAvatarView()
            // 您可以在这里通过 seatInfo.userAvatar 加载用户真实头像
            return avatarView
        }
    }
}

import AtomicXCore
import RTCRoomEngine
import SnapKit

// 自定义PK 用户视图
class CustomBattleUserView: UIView {
    private let scoreView: UIView = {
        let view = UIView()
        view.backgroundColor = .black.withAlphaComponent(0.4)
        view.layer.cornerRadius = 12
        return view
    }()

    private lazy var scoreLabel: UILabel = {
        let label = UILabel()
        label.textColor = .white
        label.font = .systemFont(ofSize: 14, weight: .bold)
        return label
    }()
    
    private var userId: String
    private let battleStore: BattleStore
    private var cancellableSet: Set<AnyCancellable> = []
    
    init(liveId: String, battleUser: TUIBattleUser) {
        self.userId = battleUser.userId
        self.battleStore = BattleStore.create(liveID: liveId)
        super.init(frame: .zero)
        backgroundColor = .clear
        isUserInteractionEnabled = false
        // UI 布局
        setupUI()
        // 订阅分数变化
        subscribeBattleState()
    }
    
    private func setupUI() {
        addSubview(scoreView)       
        scoreView.addSubview(scoreLabel)
        scoreLabel.snp.makeConstraints { make in
            make.leading.trailing.equalToSuperview().inset(5)
        }
        scoreView.snp.makeConstraints { make in
            make.height.equalTo(24)
            make.bottom.equalToSuperview().offset(-5)
            make.trailing.equalToSuperview().offset(-5)
        }
    }
    
    // 订阅 PK 分数变化
    private func subscribeBattleState() {
        battleStore.state
            .subscribe(StatePublisherSelector(keyPath: \\BattleState.battleScore))
            .removeDuplicates()
            .receive(on: RunLoop.main)
            .sink { battleUsers in
                guard let self = self else { return }
                guard let score = battleScore[self.userId] else { return }
                // 更新 UI 
                self.scoreLabel.text = "\\(battleUser.score)"
            }
            .store(in: &cancellableSet)
    }
}

// 1. 设置 LiveCoreView 自定义视图代理
coreView.videoViewDelegate = self

// 2. 让您的视图控制器遵守 VideoViewDelegate 协议
extension YourViewController: VideoViewDelegate {

    public func createBattleView(battleUser: TUIBattleUser) -> UIView? {
        // CustomBattleUserView 是您自定义的PK用户信息视图
        let customView = CustomBattleUserView(liveId:liveId, battleUser:battleUser)
        return customView
    }

}

// 1. 设置 LiveCoreView 自定义视图代理
coreView.videoViewDelegate = self

// 2. 让您的视图控制器遵守 VideoViewDelegate 协议并设置代理
extension YourViewController: VideoViewDelegate {
    func createBattleContainerView() -> UIView? {
        return CustomBattleContainerView()
    }
}