AccountContext.swift

//
//  AccountContext.swift
//  Telegram
//
//  Created by Mikhail Filimonov on 25/02/2019.
//  Copyright © 2019 Telegram. All rights reserved.
//

import Foundation
import SwiftSignalKit
import Postbox
import TelegramCore
import ColorPalette
import TGUIKit
import InAppSettings
import ThemeSettings
import Reactions
import FetchManager
#if !SHARE
import InAppPurchaseManager
#endif
import ApiCredentials

let clown: String = "🤡"
let focusIntentEmoji = "⛔️"



func bestWindow(_ accountContext: AccountContext, _ controller: ViewController?) -> Window {
    return controller?.window ?? accountContext.window
}

public struct PremiumConfiguration {
    public static var defaultValue: PremiumConfiguration {
        return PremiumConfiguration(
            isPremiumDisabled: false,
            showPremiumGiftInAttachMenu: false,
            showPremiumGiftInTextField: false,
            giveawayGiftsPurchaseAvailable: false,
            boostsPerGiftCount: 3,
            audioTransciptionTrialMaxDuration: 300,
            audioTransciptionTrialCount: 2,
            minChannelNameColorLevel: 1,
            minChannelNameIconLevel: 4,
            minChannelProfileColorLevel: 5,
            minChannelProfileIconLevel: 7,
            minChannelEmojiStatusLevel: 8,
            minChannelWallpaperLevel: 9,
            minChannelCustomWallpaperLevel: 10,
            minChannelRestrictAdsLevel: 50,
            minGroupProfileIconLevel: 7,
            minGroupEmojiStatusLevel: 8,
            minGroupWallpaperLevel: 9,
            minGroupCustomWallpaperLevel: 9,
            minGroupEmojiPackLevel: 9,
            minGroupAudioTranscriptionLevel: 9
        )
    }
    
    public let isPremiumDisabled: Bool
    public let showPremiumGiftInAttachMenu: Bool
    public let showPremiumGiftInTextField: Bool
    public let giveawayGiftsPurchaseAvailable: Bool
    public let boostsPerGiftCount: Int32
    public let audioTransciptionTrialMaxDuration: Int32
    public let audioTransciptionTrialCount: Int32
    public let minChannelNameColorLevel: Int32
    public let minChannelNameIconLevel: Int32
    public let minChannelProfileColorLevel: Int32
    public let minChannelProfileIconLevel: Int32
    public let minChannelEmojiStatusLevel: Int32
    public let minChannelWallpaperLevel: Int32
    public let minChannelCustomWallpaperLevel: Int32
    public let minChannelRestrictAdsLevel: Int32

    
    public let minGroupProfileIconLevel: Int32
    public let minGroupEmojiStatusLevel: Int32
    public let minGroupWallpaperLevel: Int32
    public let minGroupCustomWallpaperLevel: Int32
    public let minGroupEmojiPackLevel: Int32
    public let minGroupAudioTranscriptionLevel: Int32
    
    fileprivate init(
        isPremiumDisabled: Bool,
        showPremiumGiftInAttachMenu: Bool,
        showPremiumGiftInTextField: Bool,
        giveawayGiftsPurchaseAvailable: Bool,
        boostsPerGiftCount: Int32,
        audioTransciptionTrialMaxDuration: Int32,
        audioTransciptionTrialCount: Int32,
        minChannelNameColorLevel: Int32,
        minChannelNameIconLevel: Int32,
        minChannelProfileColorLevel: Int32,
        minChannelProfileIconLevel: Int32,
        minChannelEmojiStatusLevel: Int32,
        minChannelWallpaperLevel: Int32,
        minChannelCustomWallpaperLevel: Int32,
        minChannelRestrictAdsLevel: Int32,
        minGroupProfileIconLevel: Int32,
        minGroupEmojiStatusLevel: Int32,
        minGroupWallpaperLevel: Int32,
        minGroupCustomWallpaperLevel: Int32,
        minGroupEmojiPackLevel: Int32,
        minGroupAudioTranscriptionLevel: Int32
    ) {
        self.isPremiumDisabled = isPremiumDisabled
        self.showPremiumGiftInAttachMenu = showPremiumGiftInAttachMenu
        self.showPremiumGiftInTextField = showPremiumGiftInTextField
        self.giveawayGiftsPurchaseAvailable = giveawayGiftsPurchaseAvailable
        self.boostsPerGiftCount = boostsPerGiftCount
        self.audioTransciptionTrialMaxDuration = audioTransciptionTrialMaxDuration
        self.audioTransciptionTrialCount = audioTransciptionTrialCount
        self.minChannelNameColorLevel = minChannelNameColorLevel
        self.minChannelNameIconLevel = minChannelNameIconLevel
        self.minChannelProfileColorLevel = minChannelProfileColorLevel
        self.minChannelProfileIconLevel = minChannelProfileIconLevel
        self.minChannelEmojiStatusLevel = minChannelEmojiStatusLevel
        self.minChannelWallpaperLevel = minChannelWallpaperLevel
        self.minChannelCustomWallpaperLevel = minChannelCustomWallpaperLevel
        self.minChannelRestrictAdsLevel = minChannelRestrictAdsLevel
        self.minGroupProfileIconLevel = minGroupProfileIconLevel
        self.minGroupEmojiStatusLevel = minGroupEmojiStatusLevel
        self.minGroupWallpaperLevel = minGroupWallpaperLevel
        self.minGroupCustomWallpaperLevel = minGroupCustomWallpaperLevel
        self.minGroupEmojiPackLevel = minGroupEmojiPackLevel
        self.minGroupAudioTranscriptionLevel = minGroupAudioTranscriptionLevel
    }
    
    public static func with(appConfiguration: AppConfiguration) -> PremiumConfiguration {
        let defaultValue = self.defaultValue
        if let data = appConfiguration.data {
            func get(_ value: Any?) -> Int32? {
                return (value as? Double).flatMap(Int32.init)
            }
            return PremiumConfiguration(
                isPremiumDisabled: data["premium_purchase_blocked"] as? Bool ?? defaultValue.isPremiumDisabled,
                showPremiumGiftInAttachMenu: data["premium_gift_attach_menu_icon"] as? Bool ?? defaultValue.showPremiumGiftInAttachMenu,
                showPremiumGiftInTextField: data["premium_gift_text_field_icon"] as? Bool ?? defaultValue.showPremiumGiftInTextField,
                giveawayGiftsPurchaseAvailable: data["giveaway_gifts_purchase_available"] as? Bool ?? defaultValue.giveawayGiftsPurchaseAvailable,
                boostsPerGiftCount: get(data["boosts_per_sent_gift"]) ?? defaultValue.boostsPerGiftCount,
                audioTransciptionTrialMaxDuration: get(data["transcribe_audio_trial_duration_max"]) ?? defaultValue.audioTransciptionTrialMaxDuration,
                audioTransciptionTrialCount: get(data["transcribe_audio_trial_weekly_number"]) ?? defaultValue.audioTransciptionTrialCount,
                minChannelNameColorLevel: get(data["channel_color_level_min"]) ?? defaultValue.minChannelNameColorLevel,
                minChannelNameIconLevel: get(data["channel_bg_icon_level_min"]) ?? defaultValue.minChannelNameIconLevel,
                minChannelProfileColorLevel: get(data["channel_profile_color_level_min"]) ?? defaultValue.minChannelProfileColorLevel,
                minChannelProfileIconLevel: get(data["channel_profile_bg_icon_level_min"]) ?? defaultValue.minChannelProfileIconLevel,
                minChannelEmojiStatusLevel: get(data["channel_emoji_status_level_min"]) ?? defaultValue.minChannelEmojiStatusLevel,
                minChannelWallpaperLevel: get(data["channel_wallpaper_level_min"]) ?? defaultValue.minChannelWallpaperLevel,
                minChannelCustomWallpaperLevel: get(data["channel_custom_wallpaper_level_min"]) ?? defaultValue.minChannelCustomWallpaperLevel,
                minChannelRestrictAdsLevel: get(data["channel_restrict_sponsored_level_min"]) ?? defaultValue.minChannelRestrictAdsLevel,
                minGroupProfileIconLevel: get(data["group_profile_bg_icon_level_min "]) ?? defaultValue.minGroupProfileIconLevel,
                minGroupEmojiStatusLevel: get(data["group_emoji_status_level_min"]) ?? defaultValue.minGroupEmojiStatusLevel,
                minGroupWallpaperLevel: get(data["group_wallpaper_level_min"]) ?? defaultValue.minGroupWallpaperLevel,
                minGroupCustomWallpaperLevel: get(data["group_custom_wallpaper_level_min"]) ?? defaultValue.minGroupCustomWallpaperLevel,
                minGroupEmojiPackLevel: get(data["group_emoji_stickers_level_min"]) ?? defaultValue.minGroupEmojiPackLevel,
                minGroupAudioTranscriptionLevel: get(data["group_transcribe_level_min"]) ?? defaultValue.minGroupAudioTranscriptionLevel
            )
        } else {
            return defaultValue
        }
    }
}





extension AppConfiguration {
    func getGeneralValue(_ key: String, orElse defaultValue: Int32) -> Int32 {
        if let value = self.data?[key] as? Double {
            return Int32(value)
        } else {
            return defaultValue
        }
    }
    func getStringValue(_ key: String, orElse defaultValue: String) -> String {
        if let value = self.data?[key] as? String {
            return value
        } else {
            return defaultValue
        }
    }
    func getBoolValue(_ key: String, orElse defaultValue: Bool) -> Bool {
        if let value = self.data?[key] as? Bool {
            return value
        } else {
            return defaultValue
        }
    }
}

private let globalStoryDisposable = MetaDisposable()

func SetOpenStoryDisposable(_ disposable: Disposable?) {
    globalStoryDisposable.set(disposable)
}
func CancelOpenStory() {
    globalStoryDisposable.set(nil)
}





struct AntiSpamBotConfiguration {
    static var defaultValue: AntiSpamBotConfiguration {
        return AntiSpamBotConfiguration(antiSpamBotId: nil, group_size_min: 100)
    }
    
    let antiSpamBotId: EnginePeer.Id?
    let group_size_min: Int32
    fileprivate init(antiSpamBotId: EnginePeer.Id?, group_size_min: Int32) {
        self.antiSpamBotId = antiSpamBotId
        self.group_size_min = group_size_min
    }
    
    static func with(appConfiguration: AppConfiguration) -> AntiSpamBotConfiguration {
        if let data = appConfiguration.data, let string = data["telegram_antispam_user_id"] as? String, let value = Int64(string) {
            let group_size_min: Int32
            
            if let string = data["telegram_antispam_group_size_min"] as? String, let value = Int32(string) {
                group_size_min = value
            } else {
                group_size_min = 100
            }
            
            return AntiSpamBotConfiguration(antiSpamBotId: EnginePeer.Id(namespace: Namespaces.Peer.CloudUser, id: EnginePeer.Id.Id._internalFromInt64Value(value)), group_size_min: group_size_min)
        } else {
            return .defaultValue
        }
    }
}



protocol ChatLocationContextHolder: AnyObject {
}

extension ChatReplyThreadMessage {
    var effectiveTopId: MessageId {
        return self.channelMessageId ?? MessageId(peerId: self.peerId, namespace: Namespaces.Message.Cloud, id: Int32(clamping: self.threadId))
    }
}


enum ChatLocation: Equatable {
    case peer(PeerId)
    case thread(ChatReplyThreadMessage)
}

extension ChatLocation {
    
    static func makeSaved(_ accountPeerId: PeerId, peerId: PeerId) -> ChatLocation {
        return .thread(.init(peerId: accountPeerId, threadId: peerId.toInt64(), channelMessageId: nil, isChannelPost: false, isForumPost: false, maxMessage: nil, maxReadIncomingMessageId: nil, maxReadOutgoingMessageId: nil, unreadCount: 0, initialFilledHoles: IndexSet(), initialAnchor: .automatic, isNotAvailable: false))
    }
    
    var unreadMessageCountsItem: UnreadMessageCountsItem {
        switch self {
        case let .peer(peerId):
            return .peer(id: peerId, handleThreads: false)
        case let .thread(data):
            return .peer(id: data.peerId, handleThreads: false)
        }
    }
    
    var postboxViewKey: PostboxViewKey {
        switch self {
        case let .peer(peerId):
            return .peer(peerId: peerId, components: [])
        case let .thread(data):
            return .peer(peerId: data.peerId, components: [])
        }
    }
    
    var pinnedItemId: PinnedItemId {
        switch self {
        case let .peer(peerId):
            return .peer(peerId)
        case let .thread(data):
            return .peer(data.peerId)
        }
    }
    
    var peerId: PeerId {
        switch self {
        case let .peer(peerId):
            return peerId
        case let .thread(data):
            return data.peerId
        }
    }
    var threadId: Int64? {
        switch self {
        case .peer:
            return nil
        case let .thread(replyThreadMessage):
            return replyThreadMessage.threadId
        }
    }
    var threadMsgId: MessageId? {
        switch self {
        case .peer:
            return nil
        case let .thread(replyThreadMessage):
            return replyThreadMessage.effectiveTopId
        }
    }
    var threadMessage: ChatReplyThreadMessage? {
        switch self {
        case .peer:
            return nil
        case let .thread(replyThreadMessage):
            return replyThreadMessage
        }
    }

}


struct TemporaryPasswordContainer {
    let date: TimeInterval
    let password: String
    
    var isActive: Bool {
        return date + 15 * 60 > Date().timeIntervalSince1970
    }
}

enum ApplyThemeUpdate {
    case local(ColorPalette)
    case cloud(TelegramTheme)
}

final class AccountContextBindings {
    #if !SHARE
    let rootNavigation: () -> MajorNavigationController
    let mainController: () -> MainViewController
    let showControllerToaster: (ControllerToaster, Bool) -> Void
    let globalSearch:(String, PeerId?)->Void
    let switchSplitLayout:(SplitViewState)->Void
    let entertainment:()->EntertainmentViewController
    let needFullsize:()->Void
    let displayUpgradeProgress:(CGFloat)->Void
    init(rootNavigation: @escaping() -> MajorNavigationController = { fatalError() }, mainController: @escaping() -> MainViewController = { fatalError() }, showControllerToaster: @escaping(ControllerToaster, Bool) -> Void = { _, _ in fatalError() }, globalSearch: @escaping(String, PeerId?) -> Void = { _, _ in fatalError() }, entertainment: @escaping()->EntertainmentViewController = { fatalError() }, switchSplitLayout: @escaping(SplitViewState)->Void = { _ in fatalError() }, needFullsize: @escaping() -> Void = { fatalError() }, displayUpgradeProgress: @escaping(CGFloat)->Void = { _ in fatalError() }) {
        self.rootNavigation = rootNavigation
        self.mainController = mainController
        self.showControllerToaster = showControllerToaster
        self.globalSearch = globalSearch
        self.entertainment = entertainment
        self.switchSplitLayout = switchSplitLayout
        self.needFullsize = needFullsize
        self.displayUpgradeProgress = displayUpgradeProgress
    }
    #endif
}

private var lastTimeFreeSpaceNotified: TimeInterval?



final class AccountContext {
    let sharedContext: SharedAccountContext
    let account: Account
    let window: Window
    
    var bindings: AccountContextBindings = AccountContextBindings()


    #if !SHARE
    let fetchManager: FetchManager
    let diceCache: DiceCache
    let inlinePacksContext: InlineStickersContext
    let cachedGroupCallContexts: AccountGroupCallContextCacheImpl
    let networkStatusManager: NetworkStatusManager
    let inAppPurchaseManager: InAppPurchaseManager
    let starsContext: StarsContext
    
    #endif
    private(set) var timeDifference:TimeInterval  = 0
    #if !SHARE
        
    
    let peerChannelMemberCategoriesContextsManager: PeerChannelMemberCategoriesContextsManager
    let blockedPeersContext: BlockedPeersContext
    let storiesBlockedPeersContext: BlockedPeersContext
    let cacheCleaner: AccountClearCache
    let activeSessionsContext: ActiveSessionsContext
    let webSessions: WebSessionsContext
    let reactions: Reactions
    let dockControl: DockControl
    private(set) var reactionSettings: ReactionSettings = ReactionSettings.default
    private let reactionSettingsDisposable = MetaDisposable()
    private var chatInterfaceTempState:[PeerId : ChatInterfaceTempState] = [:]
    
    
    private let _chatThemes: Promise<[(String, TelegramPresentationTheme)]> = Promise([])
    var chatThemes: Signal<[(String, TelegramPresentationTheme)], NoError> {
        return _chatThemes.get() |> deliverOnMainQueue
    }
    
    
    
    private let _cloudThemes:Promise<CloudThemesCachedData> = Promise()
    var cloudThemes:Signal<CloudThemesCachedData, NoError> {
        return _cloudThemes.get() |> deliverOnMainQueue
    }
    
    
    var privacy:Signal<AccountPrivacySettings?, NoError> {
        return bindings.mainController().settings.privacySettings
    }
    func updatePrivacy(_ updated: SelectivePrivacySettings, kind: SelectivePrivacySettingsKind) {
        bindings.mainController().settings.updatePrivacy(updated, kind: kind)
    }
    #endif

    
    private let _emoticonThemes = Atomic<[(String, TelegramPresentationTheme)]>(value: [])
    var emoticonThemes: [(String, TelegramPresentationTheme)] {
        return _emoticonThemes.with { $0 }
    }
    
    let cancelGlobalSearch:ValuePromise<Bool> = ValuePromise(ignoreRepeated: false)
    
    private(set) var isSupport: Bool = false

    
    var isCurrent: Bool = false {
        didSet {
            if !self.isCurrent {
                //self.callManager = nil
            }
        }
    }
    
    
    private(set) var isPremium: Bool = false {
        didSet {
            #if !SHARE
            self.reactions.isPremium = isPremium
            #endif
        }
    }
    #if !SHARE
    var premiumIsBlocked: Bool {
        return self.premiumLimits.premium_purchase_blocked
    }
    #endif
    
    private let premiumDisposable = MetaDisposable()
    
    private let globalLocationDisposable = MetaDisposable()
    let globalPeerHandler:Promise<ChatLocation?> = Promise()
    
    private let _globalLocationId = Atomic<ChatLocation?>(value: nil)
    var globalLocationId: ChatLocation? {
        return _globalLocationId.with { $0 }
    }
    
    let globalForumId:ValuePromise<PeerId?> = ValuePromise(nil, ignoreRepeated: true)
    
    func updateGlobalPeer() {
        _ = (self.globalPeerHandler.get() |> take(1)).start(next: { [weak self] location in
            self?.globalPeerHandler.set(.single(location))
        })
    }
    
    private(set) var autologinToken: String?
    
    let hasPassportSettings: Promise<Bool> = Promise(false)

    private var _recentlyPeerUsed:[PeerId] = []
    private let _recentlyUserPeerIds = ValuePromise<[PeerId]>([])
    var recentlyUserPeerIds:Signal<[PeerId], NoError> {
        return _recentlyUserPeerIds.get()
    }
    
    private(set) var recentlyPeerUsed:[PeerId] {
        set {
            _recentlyPeerUsed = newValue
            _recentlyUserPeerIds.set(newValue)
        }
        get {
            return _recentlyPeerUsed
        }
    }
    
    var peerId: PeerId {
        return account.peerId
    }
    
    private let updateDifferenceDisposable = MetaDisposable()
    private let temporaryPwdDisposable = MetaDisposable()
    private let actualizeCloudTheme = MetaDisposable()
    private let applyThemeDisposable = MetaDisposable()
    private let cloudThemeObserver = MetaDisposable()
    private let freeSpaceDisposable = MetaDisposable()
    private let prefDisposable = DisposableSet()
    private let reindexCacheDisposable = MetaDisposable()
    private let shouldReindexCacheDisposable = MetaDisposable()
    private let checkSidebarShouldEnable = MetaDisposable()
    private let actionsDisposable = DisposableSet()
    private let _limitConfiguration: Atomic<LimitsConfiguration> = Atomic(value: LimitsConfiguration.defaultValue)
    
    private var _peerNameColors: PeerNameColors?
    
    var limitConfiguration: LimitsConfiguration {
        return _limitConfiguration.with { $0 }
    }
    
    private let _appConfiguration: Atomic<AppConfiguration> = Atomic(value: AppConfiguration.defaultValue)
    
    var appConfiguration: AppConfiguration {
        return _appConfiguration.with { $0 }
    }
    
    private var cached: PeerNameColors?
    
    var peerNameColors: PeerNameColors {
        if let _peerNameColors = _peerNameColors {
            return _peerNameColors
        }
        return .init(colors: [:], darkColors: [:], displayOrder: [], profileColors: [:], profileDarkColors: [:], profilePaletteColors: [:], profilePaletteDarkColors: [:], profileStoryColors: [:], profileStoryDarkColors: [:], profileDisplayOrder: [], nameColorsChannelMinRequiredBoostLevel: [:], nameColorsGroupMinRequiredBoostLevel: [:])
    }
    
    
    private var _myPeer: Peer?
    
    var myPeer: Peer? {
        return _myPeer
    }

    
    
    private let isKeyWindowValue: ValuePromise<Bool> = ValuePromise(ignoreRepeated: true)
    
    var isKeyWindow: Signal<Bool, NoError> {
        return isKeyWindowValue.get() |> deliverOnMainQueue
    }
    
    private let _autoplayMedia: Atomic<AutoplayMediaPreferences> = Atomic(value: AutoplayMediaPreferences.defaultSettings)
    
    var autoplayMedia: AutoplayMediaPreferences {
        return _autoplayMedia.with { $0 }
    }
    
    var layout:SplitViewState = .none {
        didSet {
            self.layoutHandler.set(self.layout)
        }
    }
    
    
    private let layoutHandler:ValuePromise<SplitViewState> = ValuePromise(ignoreRepeated:true)
    var layoutValue: Signal<SplitViewState, NoError> {
        return layoutHandler.get()
    }
    
    

    var isInGlobalSearch: Bool = false
    
    
    private let _contentSettings: Atomic<ContentSettings> = Atomic(value: ContentSettings.default)
    
    var contentSettings: ContentSettings {
        return _contentSettings.with { $0 }
    }
    
    private let _stickerSettings: Atomic<StickerSettings> = Atomic(value: StickerSettings.defaultSettings)
    
    var stickerSettings: StickerSettings {
        return _stickerSettings.with { $0 }
    }
    
    
    public var closeFolderFirst: Bool = false
    
    let engine: TelegramEngine
    
    private let giftStickersValues:Promise<[TelegramMediaFile]> = Promise([])
    var giftStickers: Signal<[TelegramMediaFile], NoError> {
        return giftStickersValues.get()
    }

    public private(set) var audioTranscriptionTrial: AudioTranscription.TrialState = .defaultValue


    
    
    init(sharedContext: SharedAccountContext, window: Window, account: Account, isSupport: Bool = false) {
        self.sharedContext = sharedContext
        self.account = account
        self.window = window
        self.engine = TelegramEngine(account: account)
        self.isSupport = isSupport
        #if !SHARE
        self.inAppPurchaseManager = .init(engine: engine)
        self.peerChannelMemberCategoriesContextsManager = PeerChannelMemberCategoriesContextsManager(self.engine, account: account)
        self.diceCache = DiceCache(postbox: account.postbox, engine: self.engine)
        self.inlinePacksContext = .init(postbox: account.postbox, engine: self.engine)
        self.fetchManager = FetchManagerImpl(postbox: account.postbox, storeManager: DownloadedMediaStoreManagerImpl(postbox: account.postbox, accountManager: sharedContext.accountManager))
        self.blockedPeersContext = BlockedPeersContext(account: account, subject: .blocked)
        self.storiesBlockedPeersContext = BlockedPeersContext(account: account, subject: .stories)
        self.cacheCleaner = AccountClearCache(account: account)
        self.cachedGroupCallContexts = AccountGroupCallContextCacheImpl()
        self.activeSessionsContext = engine.privacy.activeSessions()
        self.webSessions = engine.privacy.webSessions()
        self.networkStatusManager = NetworkStatusManager(account: account, window: window, sharedContext: sharedContext)
        self.reactions = Reactions(engine)
        self.dockControl = DockControl(engine, accountManager: sharedContext.accountManager)
        self.starsContext = engine.payments.peerStarsContext()
#endif
        
        
        giftStickersValues.set(engine.stickers.loadedStickerPack(reference: .premiumGifts, forceActualized: false)
        |> map { pack in
            switch pack {
            case let .result(_, items, _):
                return items.map { $0.file }
            default:
                return []
            }
        })
        
        let engine = self.engine
        
        repliesPeerId = account.testingEnvironment ? test_repliesPeerId : prod_repliesPeerId
        
        let limitConfiguration = _limitConfiguration
        prefDisposable.add(account.postbox.preferencesView(keys: [PreferencesKeys.limitsConfiguration]).start(next: { view in
            _ = limitConfiguration.swap(view.values[PreferencesKeys.limitsConfiguration]?.get(LimitsConfiguration.self) ?? LimitsConfiguration.defaultValue)
        }))
        let appConfiguration = _appConfiguration
        prefDisposable.add(account.postbox.preferencesView(keys: [PreferencesKeys.appConfiguration]).start(next: { view in
            let configuration = view.values[PreferencesKeys.appConfiguration]?.get(AppConfiguration.self) ?? AppConfiguration.defaultValue
            _ = appConfiguration.swap(configuration)
        }))
        prefDisposable.add((account.postbox.peerView(id: account.peerId) |> deliverOnMainQueue).start(next: { [weak self] peerView in
            self?._myPeer = peerView.peers[peerView.peerId]
        }))
        
        
       
        
        
        #if !SHARE
       
        let chatThemes: Signal<[(String, TelegramPresentationTheme)], NoError> = combineLatest(appearanceSignal, engine.themes.getChatThemes(accountManager: sharedContext.accountManager)) |> mapToSignal { appearance, themes in
            var signals:[Signal<(String, TelegramPresentationTheme), NoError>] = []
            
            for theme in themes {
                let effective = theme.effectiveSettings(isDark: appearance.presentation.dark)
                if let settings = effective, let emoji = theme.emoticon?.fixed {
                    let newTheme = appearance.presentation.withUpdatedColors(settings.palette)
                    if let wallpaper = settings.wallpaper?.uiWallpaper {
                        signals.append(moveWallpaperToCache(postbox: account.postbox, wallpaper: wallpaper) |> map { wallpaper in
                            return (emoji, newTheme.withUpdatedWallpaper(.init(wallpaper: wallpaper, associated: nil)))
                        })
                    } else {
                        signals.append(.single((emoji, newTheme)))
                    }
                }
            }
            
            let first = Signal<[(String, TelegramPresentationTheme)], NoError>.single([])
            return first |> then(combineLatest(signals)) |> map { values in
                var dict: [(String, TelegramPresentationTheme)] = []
                for value in values {
                    dict.append((value.0, value.1))
                }
                return dict
            }
        }
        let themes = (chatThemes |> then(.complete() |> suspendAwareDelay(20.0 * 60.0, queue: .concurrentDefaultQueue()))) |> restart
        
        actionsDisposable.add(themes.start(next: { [weak self] values in
            self?._emoticonThemes.swap(values)
            self?._chatThemes.set(.single(values))
        }))
        
        
        let cloudThemes: Signal<[TelegramTheme], NoError> = telegramThemes(postbox: account.postbox, network: account.network, accountManager: sharedContext.accountManager) |> distinctUntilChanged(isEqual: { lhs, rhs in
            return lhs.count == rhs.count
        })
        
        let themesList: Signal<([TelegramTheme], [CloudThemesCachedData.Key : [SmartThemeCachedData]]), NoError> = cloudThemes |> mapToSignal { themes in
            var signals:[Signal<(CloudThemesCachedData.Key, Int64, TelegramPresentationTheme), NoError>] = []
            
            for key in CloudThemesCachedData.Key.all {
                for theme in themes {
                    let effective = theme.effectiveSettings(for: key.colors)
                    if let settings = effective, theme.isDefault, let _ = theme.emoticon {
                        let newTheme = appAppearance.presentation.withUpdatedColors(settings.palette)
                        if let wallpaper = settings.wallpaper?.uiWallpaper {
                            signals.append(moveWallpaperToCache(postbox: account.postbox, wallpaper: wallpaper) |> map { wallpaper in
                                return (key, theme.id, newTheme.withUpdatedWallpaper(.init(wallpaper: wallpaper, associated: nil)))
                            })
                        } else {
                            signals.append(.single((key, theme.id, newTheme)))
                        }
                    }
                }
            }
            
            return combineLatest(signals) |> mapToSignal { values in
                
                var signals: [Signal<(CloudThemesCachedData.Key, Int64, SmartThemeCachedData), NoError>] = []
                for value in values {
                    let bubbled = value.0.bubbled
                    let theme = value.2
                    let themeId = value.1
                    let key = value.0
                    if let telegramTheme = themes.first(where: { $0.id == value.1 }) {
                        signals.append(generateChatThemeThumb(palette: theme.colors, bubbled: bubbled, backgroundMode: bubbled ? theme.backgroundMode : .color(color: theme.colors.chatBackground)) |> map {
                            (key, themeId, SmartThemeCachedData(source: .cloud(telegramTheme), data: .init(appTheme: theme, previewIcon: $0, emoticon: telegramTheme.emoticon ?? telegramTheme.title)))
                        })
                    }
                }
                return combineLatest(signals) |> map { values in
                    var data:[CloudThemesCachedData.Key: [SmartThemeCachedData]] = [:]
                    for value in values {
                        var array:[SmartThemeCachedData] = data[value.0] ?? []
                        array.append(value.2)
                        data[value.0] = array
                    }
                    return (themes, data)

                }
            }
        }
        
        
        let defaultAndCustom: Signal<(SmartThemeCachedData, SmartThemeCachedData?), NoError> = combineLatest(appearanceSignal, themeSettingsView(accountManager: sharedContext.accountManager)) |> map { appearance, value -> (ThemePaletteSettings, TelegramPresentationTheme, ThemePaletteSettings?) in
            
            let `default` = value.withUpdatedToDefault(dark: appearance.presentation.dark)
                .withUpdatedCloudTheme(nil)
                .withUpdatedPalette(appearance.presentation.colors.parent.palette)
                .installDefaultWallpaper()
            
            
            let  customData = value.withUpdatedCloudTheme(appearance.presentation.cloudTheme)
                .withUpdatedPalette(appearance.presentation.colors)
                .installDefaultWallpaper()
            
            var custom: ThemePaletteSettings?
            if let cloud = customData.cloudTheme, cloud.settings == nil {
                custom = customData
            } else if let cloud = customData.cloudTheme {
                if let settings = cloud.effectiveSettings(for: value.palette.parent.palette) {
                    if customData.wallpaper.wallpaper != settings.wallpaper?.uiWallpaper {
                        custom = customData
                    }
                }
            }
            
            return (`default`, appearance.presentation, custom)
        } |> deliverOn(.concurrentBackgroundQueue()) |> mapToSignal { (value, theme, custom) in
            
            var signals:[Signal<SmartThemeCachedData, NoError>] = []
            
            let  values = [value, custom].compactMap { $0 }
            for (i, value) in values.enumerated() {
                let newTheme = theme.withUpdatedColors(value.palette).withUpdatedWallpaper(value.wallpaper)
                signals.append(moveWallpaperToCache(postbox: account.postbox, wallpaper: value.wallpaper.wallpaper) |> mapToSignal { _ in
                    return generateChatThemeThumb(palette: newTheme.colors, bubbled: value.bubbled, backgroundMode: value.bubbled ? newTheme.backgroundMode : .color(color: newTheme.colors.chatBackground))
                } |> map { previewIcon in
                    return SmartThemeCachedData(source: .local(value.palette), data: .init(appTheme: newTheme, previewIcon: previewIcon, emoticon: i == 0 ? "🏠" : "🎨"))
                })
            }
            
            return combineLatest(signals) |> map { ($0[0], $0.count == 2 ? $0[1] : nil) }
        }
        
        _cloudThemes.set(cloudThemes |> map { cloudThemes in
            return .init(themes: cloudThemes, list: [:], default: nil, custom: nil)
        })
//        _cloudThemes.set(.single(.init(themes: [], list: [:], default: nil, custom: nil)))

        let settings = account.postbox.preferencesView(keys: [PreferencesKeys.reactionSettings])
           |> map { preferencesView -> ReactionSettings in
               let reactionSettings: ReactionSettings
               if let entry = preferencesView.values[PreferencesKeys.reactionSettings], let value = entry.get(ReactionSettings.self) {
                   reactionSettings = value
               } else {
                   reactionSettings = .default
               }
               return reactionSettings
           } |> deliverOnMainQueue
        
        reactionSettingsDisposable.set(settings.start(next: { [weak self] settings in
            self?.reactionSettings = settings
        }))
        
        #endif
        
        actionsDisposable.add(combineLatest(queue: .mainQueue(), engine.accountData.observeAvailableColorOptions(scope: .profile), engine.accountData.observeAvailableColorOptions(scope: .replies)).start(next: { [weak self] profile, replies in
            self?._peerNameColors = .with(availableReplyColors: replies, availableProfileColors: profile)
        }))
        
        actionsDisposable.add((self.engine.data.subscribe(TelegramEngine.EngineData.Item.Peer.Peer(id: account.peerId))
           |> mapToSignal { peer -> Signal<AudioTranscription.TrialState, NoError> in
               let isPremium = peer?.isPremium ?? false
               if isPremium {
                   return .single(AudioTranscription.TrialState(cooldownUntilTime: nil, remainingCount: 1))
               } else {
                   return self.engine.data.subscribe(TelegramEngine.EngineData.Item.Configuration.AudioTranscriptionTrial())
               }
           }
           |> deliverOnMainQueue).startStrict(next: { [weak self] audioTranscriptionTrial in
               guard let `self` = self else {
                   return
               }
               self.audioTranscriptionTrial = audioTranscriptionTrial
           }))

        
        
        let autoplayMedia = _autoplayMedia
        prefDisposable.add(account.postbox.preferencesView(keys: [ApplicationSpecificPreferencesKeys.autoplayMedia]).start(next: { view in
            _ = autoplayMedia.swap(view.values[ApplicationSpecificPreferencesKeys.autoplayMedia]?.get(AutoplayMediaPreferences.self) ?? AutoplayMediaPreferences.defaultSettings)
        }))
        
        let contentSettings = _contentSettings
        prefDisposable.add(getContentSettings(postbox: account.postbox).start(next: { settings in
            _ = contentSettings.swap(settings)
        }))
        
        let st = _stickerSettings
        prefDisposable.add(InAppSettings.stickerSettings(postbox: account.postbox).start(next: { settings in
            _ = st.swap(settings)
        }))
        
        
        globalPeerHandler.set(.single(nil))
        
        if account.network.globalTime > 0 {
            timeDifference = floor(account.network.globalTime - Date().timeIntervalSince1970)
        }
        
        updateDifferenceDisposable.set((Signal<Void, NoError>.single(Void())
            |> delay(5, queue: Queue.mainQueue()) |> restart).start(next: { [weak self, weak account] in
                if let account = account, account.network.globalTime > 0 {
                    self?.timeDifference = floor(account.network.globalTime - Date().timeIntervalSince1970)
                }
        }))
        
        let passthrough: Atomic<Bool> = Atomic(value: false)
        let cloudSignal = appearanceSignal |> distinctUntilChanged(isEqual: { lhs, rhs -> Bool in
            return lhs.presentation.cloudTheme == rhs.presentation.cloudTheme
        }) |> take(until: { _ in
            return .init(passthrough: passthrough.swap(true), complete: false)
        })
        |> map { value in
            return (value.presentation.cloudTheme, value.presentation.colors)
        }
        |> deliverOnMainQueue
        
        cloudThemeObserver.set(cloudSignal.start(next: { [weak self] (cloud, palette) in
            let update: ApplyThemeUpdate
            if let cloud = cloud {
                update = .cloud(cloud)
            } else {
                update = .local(palette)
            }
            self?.updateTheme(update)
        }))
        
        var previous: [ChatListFilter]?
        checkSidebarShouldEnable.set(engine.peers.updatedChatListFilters().start(next: { filters in
            if previous != filters, let previous = previous {
                let prevCount = previous.count
                let newCount = filters.count
                if newCount > prevCount, newCount > 3 {
                    _ = updateChatListFolderSettings(account.postbox, { current in
                        if !current.interacted {
                            return current.withUpdatedSidebar(true)
                        } else {
                            return current
                        }
                    }).start()
                }
            }
            previous = filters
        }))
        
        
        NotificationCenter.default.addObserver(self, selector: #selector(updateKeyWindow), name: NSWindow.didBecomeKeyNotification, object: window)
        NotificationCenter.default.addObserver(self, selector: #selector(updateKeyWindow), name: NSWindow.didResignKeyNotification, object: window)
        
        
        #if !SHARE
        var freeSpaceSignal:Signal<UInt64?, NoError> = Signal { subscriber in
            
            subscriber.putNext(freeSystemGigabytes())
            subscriber.putCompletion()
            
            return ActionDisposable {
                
        }
        } |> runOn(.concurrentDefaultQueue())
        
        
        
        freeSpaceSignal = (freeSpaceSignal |> then(.complete() |> suspendAwareDelay(60.0 * 30, queue: Queue.concurrentDefaultQueue()))) |> restart
        
        
        let isLocked = (NSApp.delegate as? AppDelegate)?.passlock ?? .single(false)
        
        
        freeSpaceDisposable.set(combineLatest(queue: .mainQueue(), freeSpaceSignal, isKeyWindow, isLocked).start(next: { [weak self] space, isKeyWindow, locked in
            
            
            let limit: UInt64 = 5
            
            guard let `self` = self, isKeyWindow, !locked, let space = space, space < limit else {
                return
            }
            if lastTimeFreeSpaceNotified == nil || (lastTimeFreeSpaceNotified! + 60.0 * 60.0 * 3 < Date().timeIntervalSince1970) {
                lastTimeFreeSpaceNotified = Date().timeIntervalSince1970
                showOutOfMemoryWarning(window, freeSpace: space, context: self)
            }
            
        }))
        
        account.callSessionManager.updateVersions(versions: OngoingCallContext.versions(includeExperimental: true, includeReference: true).map { version, supportsVideo -> CallSessionManagerImplementationVersion in
            CallSessionManagerImplementationVersion(version: version, supportsVideo: supportsVideo)
        })
        
        actionsDisposable.add(requestApplicationIcons(engine: engine).start())

//        let focusIntentStatus = someAccountSetings(postbox: account.postbox) 
//        |> distinctUntilChanged(isEqual: { 
//            $0.focusIntentStatusEnabled == $1.focusIntentStatusEnabled &&
//            $0.focusIntentStatusActive == $1.focusIntentStatusActive
//        })
//        |> deliverOnMainQueue
//        
//        actionsDisposable.add(focusIntentStatus.startStandalone(next: { [weak self] settings in
//            guard let self else {
//                return
//            }
//            let setStatus:(Int64?)->Void = { [weak self] fileId in
//                guard let self else {
//                    return
//                }
//                if let fileId {
//                    let file = self.inlinePacksContext.load(fileId: fileId) |> deliverOnMainQueue
//                    _ = file.startStandalone(next: { file in
//                        _ = engine.accountData.setEmojiStatus(file: file, expirationDate: nil).start()
//                    })
//                } else {
//                    _ = engine.accountData.setEmojiStatus(file: nil, expirationDate: nil).start()
//                }
//            }
//            if settings.focusIntentStatusEnabled {
//                if let fileId = settings.focusIntentStatusActive {
//                    setStatus(fileId)
//                } else {
//                     _ = (self.diceCache.top_emojies_status |> deliverOnMainQueue).startStandalone(next: { files in
//                         if let file = files.first(where: { $0.customEmojiText == focusIntentEmoji }) {
//                             setStatus(file.fileId.id)
//                         }
//                     })
//                }
//            } else if let fileId = settings.focusIntentStatusFallback {
//                setStatus(fileId)
//            } else {
//                setStatus(nil)
//            }
//        }))
        
        #endif
        
        let isPremium: Signal<Bool, NoError> = account.postbox.peerView(id: account.peerId) |> map { view in
            return (view.peers[view.peerId] as? TelegramUser)?.flags.contains(.isPremium) ?? false
        } |> deliverOnMainQueue
        
        self.premiumDisposable.set(isPremium.start(next: { [weak self] value in
            self?.isPremium = value
        }))
        
        self.globalLocationDisposable.set(globalPeerHandler.get().start(next: { [weak self] value in
            _ = self?._globalLocationId.swap(value)
        }))
        let autologinToken = engine.data.subscribe(TelegramEngine.EngineData.Item.Configuration.Links()) |> deliverOnMainQueue
        
        actionsDisposable.add(autologinToken.start(next: { [weak self] token in
            self?.autologinToken = token.autologinToken
        }))
    }
    
    @objc private func updateKeyWindow() {
        self.isKeyWindowValue.set(window.isKeyWindow)
    }
    
    func focus() {
        window.makeKeyAndOrderFront(nil)
    }