import SwiftUI
import Bootpay
import BootpayUI

struct CreatorChannelView: View {
    let creatorId: Int
    
    @StateObject private var viewModel = CreatorChannelViewModel()
    @StateObject private var channelDonationViewModel = ChannelDonationViewModel()
    @StateObject private var liveViewModel = LiveViewModel()
    @StateObject private var mypageViewModel = MyPageViewModel()
    @AppStorage("token") private var token: String = UserDefaults.string(forKey: UserDefaultsKey.token)
    @AppStorage("auth") private var auth: Bool = UserDefaults.bool(forKey: UserDefaultsKey.auth)
    @Environment(\.dismiss) private var dismiss
    @State private var tabBarMinY: CGFloat = .greatestFiniteMagnitude
    @State private var isShowChannelDonationDialog = false
    @State private var isShowAuthView = false
    @State private var isShowAuthConfirmView = false
    @State private var isCreatorActionMenuPresented = false
    @State private var pendingAction: (() -> Void)? = nil
    @State private var payload = Payload()

    private let titleBarHeight: CGFloat = 56
    private let tabBarHeight: CGFloat = 52

    private var isOwnCreatorChannel: Bool {
        guard let creatorId = viewModel.response?.creator.creatorId else { return false }
        let userId = UserDefaults.int(forKey: .userId)
        guard userId > 0 else { return false }
        return creatorId == userId
    }
    
    init(creatorId: Int, viewModel: CreatorChannelViewModel = CreatorChannelViewModel()) {
        self.creatorId = creatorId
        _viewModel = StateObject(wrappedValue: viewModel)
    }
    
    var body: some View {
        GeometryReader { proxy in
            let titleBarBottomY = proxy.safeAreaInsets.top + titleBarHeight
            let backgroundProgress = clamp(1 - ((tabBarMinY - titleBarBottomY) / titleBarHeight))
            let isTabBarSticky = tabBarMinY <= titleBarBottomY

            ZStack(alignment: .top) {
                Color.black.ignoresSafeArea()

                ScrollView(.vertical, showsIndicators: false) {
                    VStack(spacing: 0) {
                        headerSection

                        tabBar
                            .background(
                                GeometryReader { geometry in
                                    let minY = geometry.frame(in: .global).minY
                                    Color.clear
                                        .onAppear {
                                            updateTabBarMinY(minY)
                                        }
                                        .onChange(of: minY) { value in
                                            updateTabBarMinY(value)
                                        }
                                }
                            )
                            .opacity(isTabBarSticky ? 0 : 1)

                        selectedTabContent
                    }
                }
                .ignoresSafeArea(.container, edges: .top)

                if isTabBarSticky {
                    tabBar
                        .frame(height: tabBarHeight)
                        .offset(y: titleBarHeight)
                }
                
                VStack(spacing: 0) {
                    Color.black
                        .opacity(backgroundProgress)
                        .frame(height: proxy.safeAreaInsets.top)
                    titleBar(backgroundProgress: backgroundProgress)
                    }
                    .ignoresSafeArea(.container, edges: .top)

                if viewModel.isLoading {
                    LoadingView()
                }

                if isOwnCreatorChannel && viewModel.selectedTab == .home && !viewModel.isLoading {
                    CreatorChannelFloatingActionMenu(
                        isPresented: $isCreatorActionMenuPresented,
                        onTapCommunityPost: showCommunityWrite,
                        onTapAudioContent: showAudioContentUpload,
                        onTapCreateLive: showCreateLive
                    )
                }

                if isOwnCreatorChannel && viewModel.selectedTab == .live && !viewModel.isLoading {
                    VStack {
                        Spacer()

                        CreatorChannelLiveStartButton(action: showCreateLive)
                    }
                    .ignoresSafeArea(.container, edges: .bottom)
                }

                if isShowAuthConfirmView {
                    authConfirmDialog
                }

                if isShowChannelDonationDialog {
                    LiveRoomDonationDialogView(
                        isShowing: $isShowChannelDonationDialog,
                        isAudioContentDonation: false,
                        messageLimit: 100,
                        secretLabel: I18n.MemberChannel.secretDonationLabel,
                        secretMinimumCanMessage: I18n.MemberChannel.secretDonationMinimumCanMessage,
                        shouldPrefixSecretInMessagePlaceholder: false,
                        onClickDonation: { can, message, isSecret in
                            channelDonationViewModel.postChannelDonation(
                                can: can,
                                message: message,
                                isSecret: isSecret,
                                reloadAfterSuccess: false,
                                onSuccess: {
                                    viewModel.fetchHome(creatorId: creatorId)
                                }
                            )
                        }
                    )
                }
            }
        }
        .navigationBarBackButtonHidden(true)
        .fullScreenCover(isPresented: $isShowAuthView) {
            authView
        }
        .onAppear {
            configurePayload()
            if viewModel.hasLoaded == false {
                viewModel.fetchHome(creatorId: creatorId)
            }
        }
        .sodaToast(isPresented: $viewModel.isShowPopup, message: viewModel.errorMessage, autohideIn: 1)
        .sodaToast(isPresented: $channelDonationViewModel.isShowPopup, message: channelDonationViewModel.errorMessage, autohideIn: 2)
        .onChange(of: viewModel.selectedTab) { selectedTab in
            if selectedTab != .home {
                isCreatorActionMenuPresented = false
            }
        }
    }
    
    private func titleBar(backgroundProgress: CGFloat) -> some View {
        CreatorChannelTitleBar(
            nickname: viewModel.response?.creator.nickname ?? "",
            isFollow: viewModel.response?.creator.isFollow ?? false,
            isNotify: viewModel.response?.creator.isNotify ?? false,
            backgroundProgress: backgroundProgress,
            showsCreatorActions: !isOwnCreatorChannel,
            onTapBack: {
                dismiss()
            },
            onTapFollow: {
                viewModel.creatorFollow(follow: true, notify: true)
            },
            onTapUnfollow: {
                viewModel.creatorFollow(follow: false, notify: false)
            },
            onTapNotify: {
                viewModel.creatorFollow(follow: true, notify: true)
            },
            onTapUnnotify: {
                viewModel.creatorFollow(follow: true, notify: false)
            },
            onTapMore: {}
        )
    }
    
    @ViewBuilder
    private var headerSection: some View {
        if let creator = viewModel.response?.creator {
            CreatorChannelHeaderSection(creator: creator, onTapTalk: handleTalkTap)
        }
    }
    
    private var tabBar: some View {
        CreatorChannelTabBar(selectedTab: $viewModel.selectedTab)
    }
    
    private func clamp(_ value: CGFloat) -> CGFloat {
        max(0, min(value, 1))
    }

    private func updateTabBarMinY(_ value: CGFloat) {
        guard tabBarMinY != value else { return }
        DispatchQueue.main.async {
            tabBarMinY = value
        }
    }

    @ViewBuilder
    private var selectedTabContent: some View {
        if viewModel.selectedTab == .live {
            CreatorChannelLiveTabView(
                creatorId: creatorId,
                isOwnCreatorChannel: isOwnCreatorChannel,
                onTapLive: showLiveDetail,
                onTapContent: showContentDetail
            )
        } else if viewModel.selectedTab != .home {
            CreatorChannelPlaceholderTabView(title: viewModel.selectedTab.title)
        } else if let response = viewModel.response {
            CreatorChannelHomeView(
                response: response,
                onSelectTab: selectTab,
                onTapLive: showLiveDetail,
                onTapContent: showContentDetail,
                onTapDonate: showDonationDialog,
                onTapSchedule: handleScheduleTap,
                onTapSeries: showSeriesDetail,
                onTapCommunityLike: viewModel.likeCommunityPost
            )
        } else {
            CreatorChannelPlaceholderTabView(title: viewModel.selectedTab.title)
        }
    }


    private var authConfirmDialog: some View {
        SodaDialog(
            title: I18n.Chat.Auth.dialogTitle,
            desc: I18n.Chat.Auth.dialogDescription,
            confirmButtonTitle: I18n.Chat.Auth.goToVerification,
            confirmButtonAction: {
                isShowAuthConfirmView = false
                isShowAuthView = true
            },
            cancelButtonTitle: I18n.Common.cancel,
            cancelButtonAction: {
                isShowAuthConfirmView = false
                pendingAction = nil
            },
            textAlignment: .center
        )
    }

    private var authView: some View {
        BootpayUI(payload: payload, requestType: BootpayRequest.TYPE_AUTHENTICATION)
            .onConfirm { _ in true }
            .onCancel { _ in isShowAuthView = false }
            .onError { _ in
                AppState.shared.errorMessage = I18n.Chat.Auth.authenticationError
                AppState.shared.isShowErrorPopup = true
                isShowAuthView = false
            }
            .onDone {
                DEBUG_LOG("onDone: \($0)")
                mypageViewModel.authVerify($0) {
                    auth = true
                    isShowAuthView = false
                    if let action = pendingAction {
                        pendingAction = nil
                        action()
                    }
                }
            }
            .onClose { isShowAuthView = false }
    }

    private func configurePayload() {
        payload.applicationId = BOOTPAY_APP_ID
        payload.price = 0
        payload.pg = "다날"
        payload.method = "본인인증"
        payload.orderName = "본인인증"
        payload.authenticationId = "\(UserDefaults.string(forKey: .nickname))__\(String(NSTimeIntervalSince1970))"
    }

    private func selectTab(_ tab: CreatorChannelTab) {
        switch tab {
        case .audio:
            viewModel.selectedTab = .audio
        case .series:
            viewModel.selectedTab = .series
        case .community:
            viewModel.selectedTab = .community
        case .fanTalk:
            viewModel.selectedTab = .fanTalk
        case .donation:
            viewModel.selectedTab = .donation
        default:
            viewModel.selectedTab = tab
        }
    }

    private func showContentDetail(_ contentId: Int) {
        guard contentId > 0 else { return }
        AppState.shared.setAppStep(step: .contentDetail(contentId: contentId))
    }

    private func showLiveDetail(_ roomId: Int) {
        guard roomId > 0 else { return }
        AppState.shared.setAppStep(
            step: .liveDetail(
                roomId: roomId,
                onClickParticipant: {},
                onClickReservation: {},
                onClickStart: {},
                onClickCancel: {}
            )
        )
    }

    private func showSeriesDetail(_ seriesId: Int) {
        guard seriesId > 0 else { return }
        AppState.shared.setAppStep(step: .seriesDetail(seriesId: seriesId))
    }

    private func showCommunity(_ creatorId: Int) {
        guard creatorId > 0 else { return }
        AppState.shared.setAppStep(step: .creatorCommunityAll(creatorId: creatorId))
    }

    private func showCommunityWrite() {
        isCreatorActionMenuPresented = false
        AppState.shared.setAppStep(
            step: .creatorCommunityWrite(onSuccess: {
                viewModel.fetchHome(creatorId: creatorId)
            })
        )
    }

    private func showAudioContentUpload() {
        isCreatorActionMenuPresented = false
        AppState.shared.setAppStep(
            step: .createContent(onSuccess: {
                viewModel.fetchHome(creatorId: creatorId)
            })
        )
    }

    private func showCreateLive() {
        isCreatorActionMenuPresented = false
        AppState.shared.setAppStep(step: .createLive(timeSettingMode: .NOW, onSuccess: handleCreateLiveSuccess))
    }

    private func handleCreateLiveSuccess(response: CreateLiveRoomResponse) {
        liveViewModel.getLiveMain()
        if let _ = response.channelName {
            liveViewModel.enterRoom(roomId: response.id!)
        }
        viewModel.fetchHome(creatorId: creatorId)
    }

    private func handleScheduleTap(type: CreatorActivityType, targetId: Int) {
        guard targetId > 0 else { return }

        switch type {
        case .live, .liveReplay:
            showLiveDetail(targetId)
        case .audio:
            showContentDetail(targetId)
        case .community:
            showCommunity(targetId)
        case .unknown:
            return
        }
    }

    private func handleTalkTap() {
        guard let characterId = viewModel.response?.creator.characterId, characterId > 0 else { return }

        let trimmed = token.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !trimmed.isEmpty else {
            AppState.shared.setAppStep(step: .login)
            return
        }

        let normalizedCountryCode = UserDefaults
            .string(forKey: .countryCode)
            .trimmingCharacters(in: .whitespacesAndNewlines)
            .uppercased()
        let isKoreanCountry = normalizedCountryCode.isEmpty || normalizedCountryCode == "KR"

        if isKoreanCountry && auth == false {
            pendingAction = {
                startChat(characterId: characterId)
            }
            isShowAuthConfirmView = true
            return
        }

        if !UserDefaults.isAdultContentVisible() {
            pendingAction = nil
            moveToContentSettingsWithGuideToast()
            return
        }

        startChat(characterId: characterId)
    }

    private func startChat(characterId: Int) {
        viewModel.createChatRoom(characterId: characterId) { chatRoomId in
            AppState.shared.setAppStep(step: .chatRoom(id: chatRoomId))
        }
    }

    private func moveToContentSettingsWithGuideToast() {
        AppState.shared.setPendingContentSettingsGuideMessage(I18n.Settings.adultContentEnableGuide)
        AppState.shared.setAppStep(step: .contentViewSettings)
    }

    private func showDonationDialog() {
        guard let creatorId = viewModel.response?.creator.creatorId else { return }
        channelDonationViewModel.setCreatorId(creatorId, shouldFetch: false)
        isShowChannelDonationDialog = true
    }
}

struct CreatorChannelView_Previews: PreviewProvider {
    static var previews: some View {
        CreatorChannelView(creatorId: 1, viewModel: sampleViewModel)
    }
    
    private static var sampleViewModel: CreatorChannelViewModel {
        let viewModel = CreatorChannelViewModel()
        viewModel.response = CreatorChannelHomeResponse(
            creator: CreatorChannelCreatorResponse(
                creatorId: 1,
                characterId: 10,
                nickname: "Soda Creator",
                profileImageUrl: "https://picsum.photos/600",
                followerCount: 12345,
                isAiChatAvailable: true,
                isDmAvailable: false,
                isFollow: true,
                isNotify: true
            ),
            currentLive: nil,
            latestAudioContent: CreatorChannelAudioContentResponse(
                audioContentId: 1,
                title: "최신 오디오 콘텐츠 제목",
                duration: "1:43:25",
                imageUrl: "https://picsum.photos/300/300",
                price: 0,
                isAdult: false,
                isPointAvailable: true,
                isFirstContent: true,
                seriesName: nil,
                isOriginalSeries: nil,
                isOwned: false,
                isRented: false
            ),
            channelDonations: [
                CreatorChannelDonationResponse(
                    nickname: "팬 이름 50",
                    profileImageUrl: "https://picsum.photos/120/120?1",
                    can: 50,
                    message: "크리에이터가 커뮤니티에 올린 글이 보이는 부분 크리에이터가 커뮤니티에 올린 글이 보이는 부분",
                    createdAtUtc: "2026-07-03T03:44:00Z"
                ),
                CreatorChannelDonationResponse(
                    nickname: "팬 이름 100",
                    profileImageUrl: "https://picsum.photos/120/120?2",
                    can: 100,
                    message: "51~100캔 후원 컬러를 확인하는 Preview 샘플입니다.",
                    createdAtUtc: "2026-07-03T03:43:00Z"
                ),
                CreatorChannelDonationResponse(
                    nickname: "팬 이름 500",
                    profileImageUrl: "https://picsum.photos/120/120?3",
                    can: 500,
                    message: "101~500캔 후원 컬러를 확인하는 Preview 샘플입니다.",
                    createdAtUtc: "2026-07-03T03:42:00Z"
                ),
                CreatorChannelDonationResponse(
                    nickname: "팬 이름 501",
                    profileImageUrl: "https://picsum.photos/120/120?4",
                    can: 501,
                    message: "501캔 이상 후원 컬러를 확인하는 Preview 샘플입니다.",
                    createdAtUtc: "2026-07-03T03:41:00Z"
                )
            ],
            notices: [],
            schedules: [],
            audioContents: [],
            series: [],
            communities: [],
            fanTalk: CreatorChannelFanTalkSummaryResponse(totalCount: 0, latestFanTalk: nil),
            introduce: "",
            activity: CreatorChannelActivityResponse(
                debutDateUtc: nil,
                dday: "D+1",
                liveCount: 0,
                liveDurationHours: 0,
                liveContributorCount: 0,
                audioContentCount: 0,
                seriesCount: 0
            ),
            sns: CreatorChannelSnsResponse(
                instagramUrl: "",
                fancimmUrl: "",
                xurl: "",
                youtubeUrl: "",
                kakaoOpenChatUrl: ""
            )
        )
        viewModel.hasLoaded = true
        return viewModel
    }
}